prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
| addEventListener: (listener) => { |
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/background/index.ts",
"retrieved_chunk": " if (next === 'content' && payload.kind === 'leaveChargeMode') {\n chrome.tabs.sendMessage(payload.request.senderTabId, msg);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n const sendResponse = (val: any) => {\n const res: CrxRpcResponseMessage = {\n ...msg,",
"score": 34.392481158268865
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " msg: CrxRpcRequestMessage,\n origin: CrxMessageOrigin,\n): { next?: CrxMessageOrigin; shouldBeHandled: boolean } {\n if (msg.ext !== 'nostronger' || !('request' in msg.payload) || msg.path[0] !== origin) {\n return {\n shouldBeHandled: false,\n };\n }\n msg.path.shift();\n const next = msg.path[0];",
"score": 18.403207522642226
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": "import { handleCrxRpcRequest } from '../lib/messaging';\nimport { signEvent } from '../lib/nostr';\nimport { getKeyPair, getSignPower, setSignPower } from '../lib/store';\n// * -> ...\nchrome.runtime.onMessage.addListener((msg: CrxRpcRequestMessage, sender, _sendResponse) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'background');\n if (!shouldBeHandled) {\n return;\n }\n const payload = msg.payload;",
"score": 14.798113804826823
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 11.966676151260806
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " const messageId = Math.floor(Math.random() * 1000000);\n const message: CrxRpcRequestMessage = {\n ext,\n messageId,\n src: 'nip07-provider',\n path,\n payload: req,\n };\n window.addEventListener('message', listener);\n window.postMessage(message, '*');",
"score": 10.309760478525652
}
] | typescript | addEventListener: (listener) => { |
import { wait } from './messaging';
export async function getJoyconDevice() {
const [device] = await navigator.hid.requestDevice({
filters: [
{
vendorId: 0x057e, // Nintendo vendor ID
productId: 0x2007, // joy-con R
},
],
});
if (!device) {
throw new Error('device not found.');
}
if (!device.opened) {
await device.open();
}
await setupJoycon(device);
return device;
}
export async function setupJoycon(joycon: HIDDevice) {
// set_input_report_mode_to_0x30
await communicate(joycon, [0x03, 0x30], [[14, 0x03]]);
// enabling_MCU_data_22_1
await communicate(
joycon,
[0x22, 0x01],
[
[13, 0x80],
[14, 0x22],
],
);
// enabling_MCU_data_21_21_1_1
await communicate(
joycon,
[
0x21, 0x21, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3,
],
[[14, 0x21]],
);
// get_ext_data_59
await communicate(
joycon,
[0x59],
[
[14, 0x59],
[16, 0x20],
],
);
// get_ext_dev_in_format_config_5C
await communicate(
joycon,
[
0x5c, 0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x16, 0xed, 0x34, 0x36, 0x00,
0x00, 0x00, 0x0a, 0x64, 0x0b, 0xe6, 0xa9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x90, 0xa8, 0xe1, 0x34, 0x36,
],
[[14, 0x5c]],
);
// start_external_polling_5A
await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);
// blink LED
await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);
}
async function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {
await wait<HIDInputReportEvent, void>(
| (resolve) => (event) => { |
if (event.reportId !== 0x21) {
return;
}
const data = new Uint8Array(event.data.buffer);
if (expected.every(([pos, val]) => data[pos - 1] === val)) {
resolve();
}
},
{
addEventListener: (listener) => device.addEventListener('inputreport', listener),
removeEventListener: (listener) => device.removeEventListener('inputreport', listener),
prepare: () => {
device.sendReport(
0x01,
new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),
);
},
// timeout: 5000,
},
);
}
export async function getNextStrain(joycon: HIDDevice) {
return wait<HIDInputReportEvent, number>(
(resolve) => (event) => {
const strain = getStrain(event);
if (strain) {
resolve(strain);
}
},
{
addEventListener: (listener) => joycon.addEventListener('inputreport', listener),
removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),
// timeout: 5000,
},
);
}
export function getStrain(event: HIDInputReportEvent) {
if (event.reportId === 0x30) {
return new DataView(event.data.buffer, 38, 2).getInt16(0, true);
} else {
return null;
}
}
| src/lib/ring-con.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/content/index.ts",
"retrieved_chunk": " }\n };\n joycon.addEventListener('inputreport', reportListener);\n // Wait for `leaveChargeMode` signal.\n await wait<CrxRpcRequestMessage, void>(\n (resolve) => (msg) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');\n if (!shouldBeHandled) {\n return;\n }",
"score": 18.14595878968496
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(\n openChargeWindowReq,\n );\n if (result.kind !== 'openChargeWindow') {\n throw 'Unexpected message';\n }\n // Keep sending strain signals.\n const joycon = await getJoyconDevice();\n await setupJoycon(joycon);\n const neutral = await getNextStrain(joycon);",
"score": 17.46088859988189
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": "export async function getSignPower(): Promise<number> {\n const signPower = (await get(LOCAL_STORAGE_KEY.SIGN_POWER)) ?? 0;\n return Number(signPower) || 0;\n}\nexport async function setSignPower(signPower: number) {\n await set(LOCAL_STORAGE_KEY.SIGN_POWER, signPower);\n}",
"score": 16.04764047912745
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": "export const ext: ExtName = 'nostronger';\nexport function generateMessageId() {\n return Math.floor(Math.random() * 1000000);\n}\nexport function wait<E, T>(\n createListener: (resolve: (val: T) => void) => (event: E) => void,\n params: {\n addEventListener: (listener: (event: E) => void) => void;\n removeEventListener: (listener: (event: E) => void) => void;\n prepare?: () => void;",
"score": 13.09058112506774
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": " await chrome.storage.local.set({ [key]: val });\n}\nexport async function getKeyPair(): Promise<KeyPair> {\n const { seckey, pubkey } = await get(LOCAL_STORAGE_KEY.KEY_PAIR);\n return { seckey, pubkey };\n}\nexport async function setKeyPair(seckey: string) {\n const pubkey = await calcPubkey(seckey);\n await set(LOCAL_STORAGE_KEY.KEY_PAIR, { seckey, pubkey });\n}",
"score": 11.531009219307558
}
] | typescript | (resolve) => (event) => { |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
| messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: { |
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " const messageId = Math.floor(Math.random() * 1000000);\n const message: CrxRpcRequestMessage = {\n ext,\n messageId,\n src: 'nip07-provider',\n path,\n payload: req,\n };\n window.addEventListener('message', listener);\n window.postMessage(message, '*');",
"score": 22.17236555516414
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": "// crx-rpc ------------------------------------------------\ntype ExtName = 'nostronger';\ntype CrxRpcMessage = CrxRpcRequestMessage | CrxRpcResponseMessage;\ninterface CrxRpcRequestMessage extends _CrxRpcMessageBase {\n src: CrxMessageOrigin;\n path: CrxMessageOrigin[];\n payload: CrxRpcRequestPayload;\n}\ninterface CrxRpcResponseMessage extends _CrxRpcMessageBase {\n payload: CrxRpcResponsePayload;",
"score": 21.685369886769273
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": " if (next === 'content' && payload.kind === 'leaveChargeMode') {\n chrome.tabs.sendMessage(payload.request.senderTabId, msg);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n const sendResponse = (val: any) => {\n const res: CrxRpcResponseMessage = {\n ...msg,",
"score": 16.680073419145412
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " data.messageId !== messageId ||\n data.payload.kind !== req.kind ||\n !('response' in data.payload)\n ) {\n return;\n }\n // Assumed by `data.payload.kind !== req.kind`\n const response = data.payload.response as CrxRpcResponse<T> | PromiseLike<CrxRpcResponse<T>>;\n window.removeEventListener('message', listener);\n clearInterval(timeoutId);",
"score": 13.234506605199124
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " msg: CrxRpcRequestMessage,\n origin: CrxMessageOrigin,\n): { next?: CrxMessageOrigin; shouldBeHandled: boolean } {\n if (msg.ext !== 'nostronger' || !('request' in msg.payload) || msg.path[0] !== origin) {\n return {\n shouldBeHandled: false,\n };\n }\n msg.path.shift();\n const next = msg.path[0];",
"score": 12.73656049511989
}
] | typescript | messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: { |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => | (msg) => { |
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 20.32736521231981
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'content' -> 'charge'\n kind: 'sendStrain';\n request: {\n value: number;\n neutral: number;\n };\n response: void;",
"score": 15.08276564549328
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " for (let i = 0; i < data.length; ++i) {\n value = (value << inBits) | data[i];\n bits += inBits;\n while (bits >= outBits) {\n bits -= outBits;\n result.push((value >> bits) & maxV);\n }\n }\n if (pad) {\n if (bits > 0) {",
"score": 14.109454882910729
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " }\n const data = new Uint8Array(event.data.buffer);\n if (expected.every(([pos, val]) => data[pos - 1] === val)) {\n resolve();\n }\n },\n {\n addEventListener: (listener) => device.addEventListener('inputreport', listener),\n removeEventListener: (listener) => device.removeEventListener('inputreport', listener),\n prepare: () => {",
"score": 10.58043090824086
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // start_external_polling_5A\n await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);\n // blink LED\n await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);\n}\nasync function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {\n await wait<HIDInputReportEvent, void>(\n (resolve) => (event) => {\n if (event.reportId !== 0x21) {\n return;",
"score": 10.058950027122128
}
] | typescript | (msg) => { |
import { Config, Model } from "./types.js";
import {
ChatCompletionRequestMessageRoleEnum,
Configuration,
OpenAIApi,
} from "openai";
import { ApiError } from "./errors.js";
import { asyncIterableToArray } from "./utils.js";
// https://2ality.com/2018/04/async-iter-nodejs.html#generator-%231%3A-from-chunks-to-lines
async function* chunksToLines(chunksAsync: AsyncGenerator<string>) {
let previous = "";
for await (const chunk of chunksAsync) {
const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
previous += bufferChunk;
let eolIndex;
while ((eolIndex = previous.indexOf("\n")) >= 0) {
// line includes the EOL
const line = previous.slice(0, eolIndex + 1).trimEnd();
if (line === "data: [DONE]") break;
if (line.startsWith("data: ")) {
yield line.slice("data: ".length);
}
previous = previous.slice(eolIndex + 1);
}
}
}
// Wraps openai and provides streaming API + auto selection of api function based on model
export async function* openAIQuery(
model: Model,
prompt: string,
config: Config
): AsyncGenerator<string> {
const openai = new OpenAIApi(
new Configuration({
apiKey: config.openai.apiKey,
})
);
// TODO: select right api route/function based on model
const opts = {
stream: true,
model: model.id,
messages: [
{
role: ChatCompletionRequestMessageRoleEnum.System,
content: prompt,
},
],
};
const res = await (async () => {
try {
return await openai.createChatCompletion(opts, {
responseType: "stream",
});
} catch (err) {
if (err instanceof Error) {
if ("isAxiosError" in err) {
/* @ts-ignore */
const data = await asyncIterableToArray(err.response.data);
const error = JSON.parse(data.toString()).error;
| throw new ApiError(error); |
}
}
throw err;
}
})();
/* @ts-ignore */
const stream = res.data as IncomingMessage;
for await (const chunk of chunksToLines(stream)) {
const data = JSON.parse(chunk);
const content = data.choices[0].delta.content;
// console.log({ json });
if (content) {
yield content;
}
}
}
| src/openai.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " .filter((f) => f.endsWith(\".js\") || f.endsWith(\".mjs\"))\n .map((filename) => pathJoin(path, filename));\n } catch (err) {\n if (err instanceof Error && \"code\" in err) {\n if (err.code == \"ENOENT\") {\n // ignore error: ENOENT: no such file or directory\n return [];\n }\n }\n throw err;",
"score": 42.5911936814123
},
{
"filename": "src/index.ts",
"retrieved_chunk": " }\n process.stdout.write(\"\\n\");\n } catch (err) {\n if (err instanceof AppError) {\n console.error(err.toString());\n process.exit(err.exitCode);\n }\n console.error(err);\n process.exit(1);\n }",
"score": 42.5820213433078
},
{
"filename": "src/errors.ts",
"retrieved_chunk": "}\nexport class AppError extends Error {\n cause?: Error;\n exitCode = 1;\n private static wrap(err: unknown) {\n // We don't wrap errors that indicate unexpected/programming errors\n if (isProgrammingError(err)) {\n return err;\n }\n const cause = err instanceof Error ? err : undefined;",
"score": 26.403680159174414
},
{
"filename": "src/errors.ts",
"retrieved_chunk": "const PROGRAMMING_ERROR_CLASSES: Array<typeof Error> = [\n TypeError,\n ReferenceError,\n RangeError,\n SyntaxError,\n];\nfunction isProgrammingError(err: unknown) {\n return PROGRAMMING_ERROR_CLASSES.some((ErrorClass: ErrorConstructor) => {\n return err instanceof ErrorClass;\n });",
"score": 22.000203991363588
},
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " ]);\n return promptConfig;\n } catch (err) {\n throw new AppError({\n message: `Could not find prompt ${promptId}. Are you sure it is a builtin prompt or that ${config.paths.data}/${promptId}.mjs exists?`,\n });\n }\n}\nexport async function listPrompts(config: Config) {\n const [localFiles, builtinFiles] = await Promise.all(",
"score": 21.37837422463787
}
] | typescript | throw new ApiError(error); |
import {
ChatCompletionRequestMessageRoleEnum,
Configuration as OpenAIConfiguration,
OpenAIApi,
} from "openai";
import models, { defaultModel } from "./openaiModels.js";
import { ApiError, AppError } from "./errors.js";
import { Config, Model, ParsedResponse, PromptConfiguration } from "./types.js";
import KeyValueStore from "./kvs/abstract.js";
import { openAIQuery } from "./openai.js";
import { asyncIterableToArray } from "./utils.js";
function defaultParseResponse(content: string, _input: string): ParsedResponse {
return { message: content };
}
function toModel(promptConfig: PromptConfiguration): Model {
const model = promptConfig.model
? models.get(promptConfig.model)
: defaultModel;
if (!model) {
throw new AppError({
message: `Could not find model "${promptConfig.model}"`,
});
}
return model;
}
export async function* executePromptStream(
promptConfig: PromptConfiguration,
input: string,
config: Config,
cache?: KeyValueStore<string, string>
): AsyncGenerator<string> {
const model = toModel(promptConfig);
const formattedPrompt = promptConfig.createPrompt(input);
const cacheKey = `${model.id}-${formattedPrompt}`;
if (cache) {
const cachedResponse = await cache.get(cacheKey);
if (cachedResponse) {
yield cachedResponse;
return;
}
}
| const stream = openAIQuery(model, formattedPrompt, config); |
const chunks = [];
for await (const chunk of stream) {
chunks.push(chunk);
yield chunk;
}
if (cache) {
const response = chunks.join("");
await cache.set(cacheKey, response);
}
}
export async function executePrompt(
promptConfig: PromptConfiguration,
input: string,
config: Config,
cache?: KeyValueStore<string, string>
): Promise<ParsedResponse> {
const model = toModel(promptConfig);
const parseResponse = promptConfig.parseResponse ?? defaultParseResponse;
const response = (
await asyncIterableToArray(
executePromptStream(promptConfig, input, config, cache)
)
).join("");
return parseResponse(response, input);
}
export default executePrompt;
| src/executePrompt.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/index.ts",
"retrieved_chunk": " if (!promptId || !input) {\n printUsageAndExit();\n }\n const promptConfig = await loadPromptConfig(promptId, config);\n const cache = config.useCache\n ? new FileSystemKVS({ baseDir: config.paths.cache })\n : undefined;\n const stream = executePromptStream(promptConfig, input, config, cache);\n for await (const chunk of stream) {\n process.stdout.write(chunk);",
"score": 29.59999977099415
},
{
"filename": "src/openai.ts",
"retrieved_chunk": " model: model.id,\n messages: [\n {\n role: ChatCompletionRequestMessageRoleEnum.System,\n content: prompt,\n },\n ],\n };\n const res = await (async () => {\n try {",
"score": 18.513490746814682
},
{
"filename": "src/openai.ts",
"retrieved_chunk": " config: Config\n): AsyncGenerator<string> {\n const openai = new OpenAIApi(\n new Configuration({\n apiKey: config.openai.apiKey,\n })\n );\n // TODO: select right api route/function based on model\n const opts = {\n stream: true,",
"score": 15.439736985727775
},
{
"filename": "src/openai.ts",
"retrieved_chunk": " yield line.slice(\"data: \".length);\n }\n previous = previous.slice(eolIndex + 1);\n }\n }\n}\n// Wraps openai and provides streaming API + auto selection of api function based on model\nexport async function* openAIQuery(\n model: Model,\n prompt: string,",
"score": 14.197089881018073
},
{
"filename": "src/config.ts",
"retrieved_chunk": " apiKey: getEnvOrThrow(\"OPENAI_API_KEY\"),\n },\n paths: {\n data: pathJoin(homedir(), `.${APPNAME}`),\n cache: paths.cache,\n },\n useCache: true,\n };\n debug(config);\n return config;",
"score": 13.384316349098857
}
] | typescript | const stream = openAIQuery(model, formattedPrompt, config); |
import { Config } from "./types.js";
import { join as pathJoin } from "node:path";
import { AppError } from "./errors.js";
import { fileURLToPath } from "node:url";
import { dirname, parse } from "node:path";
import { readdir } from "node:fs/promises";
async function readFilesInDirectory(path: string) {
try {
const files = await readdir(path);
return files
.filter((f) => f.endsWith(".js") || f.endsWith(".mjs"))
.map((filename) => pathJoin(path, filename));
} catch (err) {
if (err instanceof Error && "code" in err) {
if (err.code == "ENOENT") {
// ignore error: ENOENT: no such file or directory
return [];
}
}
throw err;
}
}
// Returns a path relative to import.meta.filename
export function sourceRelativePath(
meta: { url: string },
...relPaths: string[]
) {
const __dirname = dirname(fileURLToPath(meta.url));
return pathJoin(__dirname, ...relPaths);
}
export async function loadFromPath(path: string) {
const promptConfig = await import(path);
// TODO: validate promptConfig?
return promptConfig.default;
}
export async function loadPromptConfig(promptId: string, config: Config) {
try {
const promptConfig = await Promise.any([
loadFromPath(sourceRelativePath(import.meta, `./prompts/${promptId}.js`)),
| loadFromPath(pathJoin(config.paths.data, `${promptId}.mjs`)),
]); |
return promptConfig;
} catch (err) {
throw new AppError({
message: `Could not find prompt ${promptId}. Are you sure it is a builtin prompt or that ${config.paths.data}/${promptId}.mjs exists?`,
});
}
}
export async function listPrompts(config: Config) {
const [localFiles, builtinFiles] = await Promise.all(
[
sourceRelativePath(import.meta, `./prompts`),
pathJoin(config.paths.data),
].map(readFilesInDirectory)
);
const allFiles = [...localFiles, ...builtinFiles];
const allPromptConfigs = await Promise.all(allFiles.map(loadFromPath));
return allPromptConfigs.map((config, i) => {
const name = parse(allFiles[i]).name;
return {
name,
description: config.description,
};
});
}
| src/loadPromptConfig.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/index.ts",
"retrieved_chunk": " if (!promptId || !input) {\n printUsageAndExit();\n }\n const promptConfig = await loadPromptConfig(promptId, config);\n const cache = config.useCache\n ? new FileSystemKVS({ baseDir: config.paths.cache })\n : undefined;\n const stream = executePromptStream(promptConfig, input, config, cache);\n for await (const chunk of stream) {\n process.stdout.write(chunk);",
"score": 37.20358774749833
},
{
"filename": "src/index.ts",
"retrieved_chunk": "}\nexport async function cli() {\n try {\n const config = loadConfig();\n const { promptId, input: argvInput } = parseArgs(process.argv);\n if (promptId === \"--list\") {\n const prompts = await listPrompts(config);\n console.log(\n prompts\n .map((p) => {",
"score": 30.80451757783909
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": " }\n}\nexport async function executePrompt(\n promptConfig: PromptConfiguration,\n input: string,\n config: Config,\n cache?: KeyValueStore<string, string>\n): Promise<ParsedResponse> {\n const model = toModel(promptConfig);\n const parseResponse = promptConfig.parseResponse ?? defaultParseResponse;",
"score": 30.34775190432223
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": " message: `Could not find model \"${promptConfig.model}\"`,\n });\n }\n return model;\n}\nexport async function* executePromptStream(\n promptConfig: PromptConfiguration,\n input: string,\n config: Config,\n cache?: KeyValueStore<string, string>",
"score": 24.941362224557928
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": "import { asyncIterableToArray } from \"./utils.js\";\nfunction defaultParseResponse(content: string, _input: string): ParsedResponse {\n return { message: content };\n}\nfunction toModel(promptConfig: PromptConfiguration): Model {\n const model = promptConfig.model\n ? models.get(promptConfig.model)\n : defaultModel;\n if (!model) {\n throw new AppError({",
"score": 22.2566497234918
}
] | typescript | loadFromPath(pathJoin(config.paths.data, `${promptId}.mjs`)),
]); |
import { Config, Model } from "./types.js";
import {
ChatCompletionRequestMessageRoleEnum,
Configuration,
OpenAIApi,
} from "openai";
import { ApiError } from "./errors.js";
import { asyncIterableToArray } from "./utils.js";
// https://2ality.com/2018/04/async-iter-nodejs.html#generator-%231%3A-from-chunks-to-lines
async function* chunksToLines(chunksAsync: AsyncGenerator<string>) {
let previous = "";
for await (const chunk of chunksAsync) {
const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
previous += bufferChunk;
let eolIndex;
while ((eolIndex = previous.indexOf("\n")) >= 0) {
// line includes the EOL
const line = previous.slice(0, eolIndex + 1).trimEnd();
if (line === "data: [DONE]") break;
if (line.startsWith("data: ")) {
yield line.slice("data: ".length);
}
previous = previous.slice(eolIndex + 1);
}
}
}
// Wraps openai and provides streaming API + auto selection of api function based on model
export async function* openAIQuery(
model: Model,
prompt: string,
config: Config
): AsyncGenerator<string> {
const openai = new OpenAIApi(
new Configuration({
apiKey: | config.openai.apiKey,
})
); |
// TODO: select right api route/function based on model
const opts = {
stream: true,
model: model.id,
messages: [
{
role: ChatCompletionRequestMessageRoleEnum.System,
content: prompt,
},
],
};
const res = await (async () => {
try {
return await openai.createChatCompletion(opts, {
responseType: "stream",
});
} catch (err) {
if (err instanceof Error) {
if ("isAxiosError" in err) {
/* @ts-ignore */
const data = await asyncIterableToArray(err.response.data);
const error = JSON.parse(data.toString()).error;
throw new ApiError(error);
}
}
throw err;
}
})();
/* @ts-ignore */
const stream = res.data as IncomingMessage;
for await (const chunk of chunksToLines(stream)) {
const data = JSON.parse(chunk);
const content = data.choices[0].delta.content;
// console.log({ json });
if (content) {
yield content;
}
}
}
| src/openai.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/types.ts",
"retrieved_chunk": "export interface Config {\n openai: {\n apiKey: string;\n };\n useCache: boolean;\n paths: {\n data: string;\n cache: string;\n };\n}",
"score": 22.023506686046645
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": "import {\n ChatCompletionRequestMessageRoleEnum,\n Configuration as OpenAIConfiguration,\n OpenAIApi,\n} from \"openai\";\nimport models, { defaultModel } from \"./openaiModels.js\";\nimport { ApiError, AppError } from \"./errors.js\";\nimport { Config, Model, ParsedResponse, PromptConfiguration } from \"./types.js\";\nimport KeyValueStore from \"./kvs/abstract.js\";\nimport { openAIQuery } from \"./openai.js\";",
"score": 17.95377515572841
},
{
"filename": "src/config.ts",
"retrieved_chunk": " throw new ConfigError({\n message: `Please set the ${key} environment variable.`,\n });\n }\n return val;\n}\nconst paths = envPaths(APPNAME, { suffix: \"\" });\nexport function loadConfig(): Config {\n const config = {\n openai: {",
"score": 15.866284198373743
},
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " ]);\n return promptConfig;\n } catch (err) {\n throw new AppError({\n message: `Could not find prompt ${promptId}. Are you sure it is a builtin prompt or that ${config.paths.data}/${promptId}.mjs exists?`,\n });\n }\n}\nexport async function listPrompts(config: Config) {\n const [localFiles, builtinFiles] = await Promise.all(",
"score": 13.030114831219235
},
{
"filename": "src/config.ts",
"retrieved_chunk": " apiKey: getEnvOrThrow(\"OPENAI_API_KEY\"),\n },\n paths: {\n data: pathJoin(homedir(), `.${APPNAME}`),\n cache: paths.cache,\n },\n useCache: true,\n };\n debug(config);\n return config;",
"score": 12.399369396244916
}
] | typescript | config.openai.apiKey,
})
); |
import { executePrompt, executePromptStream } from "./executePrompt.js";
import { loadConfig } from "./config.js";
import { loadPromptConfig, listPrompts } from "./loadPromptConfig.js";
import { APPNAME } from "./types.js";
import FileSystemKVS from "./kvs/kvs-filesystem.js";
import { AppError } from "./errors.js";
import { readFileSync } from "node:fs";
function parseArgs(argv: string[]) {
const [_nodeBin, _jsFile, promptId, ...rest] = argv;
const input = rest.join(" ");
return { promptId, input };
}
function printUsageAndExit() {
console.log("Usage:");
console.log(`$ ${APPNAME} <promptType> <input>`);
console.log(`$ ${APPNAME} --list`);
console.log("");
console.log("Example: ");
console.log("");
console.log(`$ ${APPNAME} eli5 "what are large language models?"`);
process.exit(1);
}
function getInput(argvInput: string) {
try {
const stdinInput = readFileSync(process.stdin.fd, "utf-8");
// console.log({ stdinInput });
return `${argvInput} ${stdinInput}`;
} catch (err) {
return argvInput;
}
}
export async function cli() {
try {
const config = loadConfig();
const { promptId, input: argvInput } = parseArgs(process.argv);
if (promptId === "--list") {
const prompts = await listPrompts(config);
console.log(
prompts
.map((p) => {
const description = p.description ? `: ${p.description}` : "";
return `${p.name}${description}`;
})
.join("\n")
);
return;
} else if (promptId && promptId.startsWith("--")) {
printUsageAndExit();
}
const input = getInput(argvInput);
if (!promptId || !input) {
printUsageAndExit();
}
const promptConfig = await loadPromptConfig(promptId, config);
const cache = config.useCache
? | new FileSystemKVS({ baseDir: config.paths.cache })
: undefined; |
const stream = executePromptStream(promptConfig, input, config, cache);
for await (const chunk of stream) {
process.stdout.write(chunk);
}
process.stdout.write("\n");
} catch (err) {
if (err instanceof AppError) {
console.error(err.toString());
process.exit(err.exitCode);
}
console.error(err);
process.exit(1);
}
}
export default cli;
| src/index.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": "export async function loadFromPath(path: string) {\n const promptConfig = await import(path);\n // TODO: validate promptConfig?\n return promptConfig.default;\n}\nexport async function loadPromptConfig(promptId: string, config: Config) {\n try {\n const promptConfig = await Promise.any([\n loadFromPath(sourceRelativePath(import.meta, `./prompts/${promptId}.js`)),\n loadFromPath(pathJoin(config.paths.data, `${promptId}.mjs`)),",
"score": 27.24368845756548
},
{
"filename": "src/config.ts",
"retrieved_chunk": " apiKey: getEnvOrThrow(\"OPENAI_API_KEY\"),\n },\n paths: {\n data: pathJoin(homedir(), `.${APPNAME}`),\n cache: paths.cache,\n },\n useCache: true,\n };\n debug(config);\n return config;",
"score": 21.876415717747566
},
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " ]);\n return promptConfig;\n } catch (err) {\n throw new AppError({\n message: `Could not find prompt ${promptId}. Are you sure it is a builtin prompt or that ${config.paths.data}/${promptId}.mjs exists?`,\n });\n }\n}\nexport async function listPrompts(config: Config) {\n const [localFiles, builtinFiles] = await Promise.all(",
"score": 21.551173551481508
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": " const response = (\n await asyncIterableToArray(\n executePromptStream(promptConfig, input, config, cache)\n )\n ).join(\"\");\n return parseResponse(response, input);\n}\nexport default executePrompt;",
"score": 20.658324077636312
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": " }\n}\nexport async function executePrompt(\n promptConfig: PromptConfiguration,\n input: string,\n config: Config,\n cache?: KeyValueStore<string, string>\n): Promise<ParsedResponse> {\n const model = toModel(promptConfig);\n const parseResponse = promptConfig.parseResponse ?? defaultParseResponse;",
"score": 18.70475749622126
}
] | typescript | new FileSystemKVS({ baseDir: config.paths.cache })
: undefined; |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await | wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => { |
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 20.32736521231981
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'content' -> 'charge'\n kind: 'sendStrain';\n request: {\n value: number;\n neutral: number;\n };\n response: void;",
"score": 15.08276564549328
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " for (let i = 0; i < data.length; ++i) {\n value = (value << inBits) | data[i];\n bits += inBits;\n while (bits >= outBits) {\n bits -= outBits;\n result.push((value >> bits) & maxV);\n }\n }\n if (pad) {\n if (bits > 0) {",
"score": 14.109454882910729
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " }\n const data = new Uint8Array(event.data.buffer);\n if (expected.every(([pos, val]) => data[pos - 1] === val)) {\n resolve();\n }\n },\n {\n addEventListener: (listener) => device.addEventListener('inputreport', listener),\n removeEventListener: (listener) => device.removeEventListener('inputreport', listener),\n prepare: () => {",
"score": 10.58043090824086
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // start_external_polling_5A\n await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);\n // blink LED\n await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);\n}\nasync function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {\n await wait<HIDInputReportEvent, void>(\n (resolve) => (event) => {\n if (event.reportId !== 0x21) {\n return;",
"score": 10.058950027122128
}
] | typescript | wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => { |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
| (resolve) => (msg) => { |
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 23.47522542211614
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'content' -> 'charge'\n kind: 'sendStrain';\n request: {\n value: number;\n neutral: number;\n };\n response: void;",
"score": 15.08276564549328
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " for (let i = 0; i < data.length; ++i) {\n value = (value << inBits) | data[i];\n bits += inBits;\n while (bits >= outBits) {\n bits -= outBits;\n result.push((value >> bits) & maxV);\n }\n }\n if (pad) {\n if (bits > 0) {",
"score": 14.109454882910729
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // start_external_polling_5A\n await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);\n // blink LED\n await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);\n}\nasync function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {\n await wait<HIDInputReportEvent, void>(\n (resolve) => (event) => {\n if (event.reportId !== 0x21) {\n return;",
"score": 12.278015776126102
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " const timeoutId = timeout\n ? setTimeout(() => {\n window.removeEventListener('message', listener);\n reject(`Request \\`${req.kind}\\` timed out`);\n }, timeout)\n : -1;\n function listener(ev: MessageEvent<CrxRpcResponseMessage>) {\n const data = ev.data;\n if (\n data.ext !== 'nostronger' ||",
"score": 12.165149192935633
}
] | typescript | (resolve) => (msg) => { |
import { wait } from './messaging';
export async function getJoyconDevice() {
const [device] = await navigator.hid.requestDevice({
filters: [
{
vendorId: 0x057e, // Nintendo vendor ID
productId: 0x2007, // joy-con R
},
],
});
if (!device) {
throw new Error('device not found.');
}
if (!device.opened) {
await device.open();
}
await setupJoycon(device);
return device;
}
export async function setupJoycon(joycon: HIDDevice) {
// set_input_report_mode_to_0x30
await communicate(joycon, [0x03, 0x30], [[14, 0x03]]);
// enabling_MCU_data_22_1
await communicate(
joycon,
[0x22, 0x01],
[
[13, 0x80],
[14, 0x22],
],
);
// enabling_MCU_data_21_21_1_1
await communicate(
joycon,
[
0x21, 0x21, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3,
],
[[14, 0x21]],
);
// get_ext_data_59
await communicate(
joycon,
[0x59],
[
[14, 0x59],
[16, 0x20],
],
);
// get_ext_dev_in_format_config_5C
await communicate(
joycon,
[
0x5c, 0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x16, 0xed, 0x34, 0x36, 0x00,
0x00, 0x00, 0x0a, 0x64, 0x0b, 0xe6, 0xa9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x90, 0xa8, 0xe1, 0x34, 0x36,
],
[[14, 0x5c]],
);
// start_external_polling_5A
await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);
// blink LED
await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);
}
async function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {
| await wait<HIDInputReportEvent, void>(
(resolve) => (event) => { |
if (event.reportId !== 0x21) {
return;
}
const data = new Uint8Array(event.data.buffer);
if (expected.every(([pos, val]) => data[pos - 1] === val)) {
resolve();
}
},
{
addEventListener: (listener) => device.addEventListener('inputreport', listener),
removeEventListener: (listener) => device.removeEventListener('inputreport', listener),
prepare: () => {
device.sendReport(
0x01,
new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),
);
},
// timeout: 5000,
},
);
}
export async function getNextStrain(joycon: HIDDevice) {
return wait<HIDInputReportEvent, number>(
(resolve) => (event) => {
const strain = getStrain(event);
if (strain) {
resolve(strain);
}
},
{
addEventListener: (listener) => joycon.addEventListener('inputreport', listener),
removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),
// timeout: 5000,
},
);
}
export function getStrain(event: HIDInputReportEvent) {
if (event.reportId === 0x30) {
return new DataView(event.data.buffer, 38, 2).getInt16(0, true);
} else {
return null;
}
}
| src/lib/ring-con.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/content/index.ts",
"retrieved_chunk": " }\n };\n joycon.addEventListener('inputreport', reportListener);\n // Wait for `leaveChargeMode` signal.\n await wait<CrxRpcRequestMessage, void>(\n (resolve) => (msg) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');\n if (!shouldBeHandled) {\n return;\n }",
"score": 18.14595878968496
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(\n openChargeWindowReq,\n );\n if (result.kind !== 'openChargeWindow') {\n throw 'Unexpected message';\n }\n // Keep sending strain signals.\n const joycon = await getJoyconDevice();\n await setupJoycon(joycon);\n const neutral = await getNextStrain(joycon);",
"score": 17.46088859988189
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": "export async function getSignPower(): Promise<number> {\n const signPower = (await get(LOCAL_STORAGE_KEY.SIGN_POWER)) ?? 0;\n return Number(signPower) || 0;\n}\nexport async function setSignPower(signPower: number) {\n await set(LOCAL_STORAGE_KEY.SIGN_POWER, signPower);\n}",
"score": 16.04764047912745
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": "export const ext: ExtName = 'nostronger';\nexport function generateMessageId() {\n return Math.floor(Math.random() * 1000000);\n}\nexport function wait<E, T>(\n createListener: (resolve: (val: T) => void) => (event: E) => void,\n params: {\n addEventListener: (listener: (event: E) => void) => void;\n removeEventListener: (listener: (event: E) => void) => void;\n prepare?: () => void;",
"score": 13.09058112506774
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": " await chrome.storage.local.set({ [key]: val });\n}\nexport async function getKeyPair(): Promise<KeyPair> {\n const { seckey, pubkey } = await get(LOCAL_STORAGE_KEY.KEY_PAIR);\n return { seckey, pubkey };\n}\nexport async function setKeyPair(seckey: string) {\n const pubkey = await calcPubkey(seckey);\n await set(LOCAL_STORAGE_KEY.KEY_PAIR, { seckey, pubkey });\n}",
"score": 11.531009219307558
}
] | typescript | await wait<HIDInputReportEvent, void>(
(resolve) => (event) => { |
import { wait } from './messaging';
export async function getJoyconDevice() {
const [device] = await navigator.hid.requestDevice({
filters: [
{
vendorId: 0x057e, // Nintendo vendor ID
productId: 0x2007, // joy-con R
},
],
});
if (!device) {
throw new Error('device not found.');
}
if (!device.opened) {
await device.open();
}
await setupJoycon(device);
return device;
}
export async function setupJoycon(joycon: HIDDevice) {
// set_input_report_mode_to_0x30
await communicate(joycon, [0x03, 0x30], [[14, 0x03]]);
// enabling_MCU_data_22_1
await communicate(
joycon,
[0x22, 0x01],
[
[13, 0x80],
[14, 0x22],
],
);
// enabling_MCU_data_21_21_1_1
await communicate(
joycon,
[
0x21, 0x21, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3,
],
[[14, 0x21]],
);
// get_ext_data_59
await communicate(
joycon,
[0x59],
[
[14, 0x59],
[16, 0x20],
],
);
// get_ext_dev_in_format_config_5C
await communicate(
joycon,
[
0x5c, 0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x16, 0xed, 0x34, 0x36, 0x00,
0x00, 0x00, 0x0a, 0x64, 0x0b, 0xe6, 0xa9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x90, 0xa8, 0xe1, 0x34, 0x36,
],
[[14, 0x5c]],
);
// start_external_polling_5A
await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);
// blink LED
await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);
}
async function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {
await wait<HIDInputReportEvent, void>(
(resolve) | => (event) => { |
if (event.reportId !== 0x21) {
return;
}
const data = new Uint8Array(event.data.buffer);
if (expected.every(([pos, val]) => data[pos - 1] === val)) {
resolve();
}
},
{
addEventListener: (listener) => device.addEventListener('inputreport', listener),
removeEventListener: (listener) => device.removeEventListener('inputreport', listener),
prepare: () => {
device.sendReport(
0x01,
new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),
);
},
// timeout: 5000,
},
);
}
export async function getNextStrain(joycon: HIDDevice) {
return wait<HIDInputReportEvent, number>(
(resolve) => (event) => {
const strain = getStrain(event);
if (strain) {
resolve(strain);
}
},
{
addEventListener: (listener) => joycon.addEventListener('inputreport', listener),
removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),
// timeout: 5000,
},
);
}
export function getStrain(event: HIDInputReportEvent) {
if (event.reportId === 0x30) {
return new DataView(event.data.buffer, 38, 2).getInt16(0, true);
} else {
return null;
}
}
| src/lib/ring-con.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/content/index.ts",
"retrieved_chunk": " }\n };\n joycon.addEventListener('inputreport', reportListener);\n // Wait for `leaveChargeMode` signal.\n await wait<CrxRpcRequestMessage, void>(\n (resolve) => (msg) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');\n if (!shouldBeHandled) {\n return;\n }",
"score": 18.14595878968496
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(\n openChargeWindowReq,\n );\n if (result.kind !== 'openChargeWindow') {\n throw 'Unexpected message';\n }\n // Keep sending strain signals.\n const joycon = await getJoyconDevice();\n await setupJoycon(joycon);\n const neutral = await getNextStrain(joycon);",
"score": 17.46088859988189
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": "export async function getSignPower(): Promise<number> {\n const signPower = (await get(LOCAL_STORAGE_KEY.SIGN_POWER)) ?? 0;\n return Number(signPower) || 0;\n}\nexport async function setSignPower(signPower: number) {\n await set(LOCAL_STORAGE_KEY.SIGN_POWER, signPower);\n}",
"score": 16.04764047912745
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": "export const ext: ExtName = 'nostronger';\nexport function generateMessageId() {\n return Math.floor(Math.random() * 1000000);\n}\nexport function wait<E, T>(\n createListener: (resolve: (val: T) => void) => (event: E) => void,\n params: {\n addEventListener: (listener: (event: E) => void) => void;\n removeEventListener: (listener: (event: E) => void) => void;\n prepare?: () => void;",
"score": 13.09058112506774
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": " await chrome.storage.local.set({ [key]: val });\n}\nexport async function getKeyPair(): Promise<KeyPair> {\n const { seckey, pubkey } = await get(LOCAL_STORAGE_KEY.KEY_PAIR);\n return { seckey, pubkey };\n}\nexport async function setKeyPair(seckey: string) {\n const pubkey = await calcPubkey(seckey);\n await set(LOCAL_STORAGE_KEY.KEY_PAIR, { seckey, pubkey });\n}",
"score": 11.531009219307558
}
] | typescript | => (event) => { |
import { handleCrxRpcRequest } from '../lib/messaging';
import { signEvent } from '../lib/nostr';
import { getKeyPair, getSignPower, setSignPower } from '../lib/store';
// * -> ...
chrome.runtime.onMessage.addListener((msg: CrxRpcRequestMessage, sender, _sendResponse) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'background');
if (!shouldBeHandled) {
return;
}
const payload = msg.payload;
if (next === 'content' && payload.kind === 'leaveChargeMode') {
chrome.tabs.sendMessage(payload.request.senderTabId, msg);
return;
} else if (!!next) {
console.warn('Unexpected message', msg);
return;
}
const sendResponse = (val: any) => {
const res: CrxRpcResponseMessage = {
...msg,
payload: {
kind: payload.kind,
response: val,
},
};
_sendResponse(res);
};
// ... -> HERE
switch (payload.kind) {
case 'getPubkey':
getKeyPair().then(({ pubkey }) => {
sendResponse(pubkey);
});
return true; // For async response
case 'signEvent':
getKeyPair().then(async (keypair) => {
const | signed = await signEvent(keypair, payload.request); |
sendResponse(signed);
});
return true;
case 'getSignPower':
getSignPower().then((power) => {
sendResponse(power);
});
return true;
case 'setSignPower':
setSignPower(payload.request.value).then(() => {
sendResponse(void 0);
});
return true;
case 'openChargeWindow':
chrome.windows
.create({
url: chrome.runtime.getURL('charge.html'),
type: 'popup',
})
.then((res) => {
const tabId = res.tabs?.[0].id;
sendResponse(tabId);
});
return true;
default:
break;
}
});
| src/background/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/store.ts",
"retrieved_chunk": " await chrome.storage.local.set({ [key]: val });\n}\nexport async function getKeyPair(): Promise<KeyPair> {\n const { seckey, pubkey } = await get(LOCAL_STORAGE_KEY.KEY_PAIR);\n return { seckey, pubkey };\n}\nexport async function setKeyPair(seckey: string) {\n const pubkey = await calcPubkey(seckey);\n await set(LOCAL_STORAGE_KEY.KEY_PAIR, { seckey, pubkey });\n}",
"score": 20.01271745177093
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " kind: 'getPubkey';\n request: {};\n response: string;\n }\n | {\n // possible paths:\n // - 'nip07-provider' -> 'content' -> 'background'\n kind: 'signEvent';\n request: UnsignedEvent;\n response: SignedEvent;",
"score": 15.43600516029743
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " },\n async signEvent(event: UnsignedEvent): Promise<SignedEvent | undefined> {\n let signPower = await rpc(\n {\n kind: 'getSignPower',\n request: {},\n },\n ['content', 'background'],\n );\n if (signPower <= 0) {",
"score": 12.693331142311196
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " case 'enterChargeMode':\n {\n try {\n const response = await enterChargeMode(data);\n window.postMessage(response);\n } catch (err) {\n console.error(err);\n window.postMessage({\n ext,\n messageId: data.messageId,",
"score": 11.68716081009935
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " // ... -> HERE -> 'background'\n const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);\n window.postMessage(response);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', data);\n return;\n }\n //... -> HERE\n switch (data.payload.kind) {",
"score": 11.146483968071767
}
] | typescript | signed = await signEvent(keypair, payload.request); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const | neutral = await getNextStrain(joycon); |
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " if (!device) {\n throw new Error('device not found.');\n }\n if (!device.opened) {\n await device.open();\n }\n await setupJoycon(device);\n return device;\n}\nexport async function setupJoycon(joycon: HIDDevice) {",
"score": 21.484170625589183
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 15.922052004413642
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // set_input_report_mode_to_0x30\n await communicate(joycon, [0x03, 0x30], [[14, 0x03]]);\n // enabling_MCU_data_22_1\n await communicate(\n joycon,\n [0x22, 0x01],\n [\n [13, 0x80],\n [14, 0x22],\n ],",
"score": 15.069291575040475
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " );\n // get_ext_data_59\n await communicate(\n joycon,\n [0x59],\n [\n [14, 0x59],\n [16, 0x20],\n ],\n );",
"score": 13.480109089477603
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // start_external_polling_5A\n await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);\n // blink LED\n await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);\n}\nasync function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {\n await wait<HIDInputReportEvent, void>(\n (resolve) => (event) => {\n if (event.reportId !== 0x21) {\n return;",
"score": 13.269111507486155
}
] | typescript | neutral = await getNextStrain(joycon); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const | value = getStrain(ev); |
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " const timeoutId = timeout\n ? setTimeout(() => {\n window.removeEventListener('message', listener);\n reject(`Request \\`${req.kind}\\` timed out`);\n }, timeout)\n : -1;\n function listener(ev: MessageEvent<CrxRpcResponseMessage>) {\n const data = ev.data;\n if (\n data.ext !== 'nostronger' ||",
"score": 13.512845465030061
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'content' -> 'charge'\n kind: 'sendStrain';\n request: {\n value: number;\n neutral: number;\n };\n response: void;",
"score": 9.92361224220594
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": " case 'openChargeWindow':\n chrome.windows\n .create({\n url: chrome.runtime.getURL('charge.html'),\n type: 'popup',\n })\n .then((res) => {\n const tabId = res.tabs?.[0].id;\n sendResponse(tabId);\n });",
"score": 7.252834533997848
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 6.643154380996037
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " for (let i = 0; i < data.length; ++i) {\n value = (value << inBits) | data[i];\n bits += inBits;\n while (bits >= outBits) {\n bits -= outBits;\n result.push((value >> bits) & maxV);\n }\n }\n if (pad) {\n if (bits > 0) {",
"score": 6.419865338508484
}
] | typescript | value = getStrain(ev); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
| await setupJoycon(joycon); |
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " if (!device) {\n throw new Error('device not found.');\n }\n if (!device.opened) {\n await device.open();\n }\n await setupJoycon(device);\n return device;\n}\nexport async function setupJoycon(joycon: HIDDevice) {",
"score": 19.603576991907765
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": " if (next === 'content' && payload.kind === 'leaveChargeMode') {\n chrome.tabs.sendMessage(payload.request.senderTabId, msg);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n const sendResponse = (val: any) => {\n const res: CrxRpcResponseMessage = {\n ...msg,",
"score": 19.210732427088956
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 13.271203404456985
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // set_input_report_mode_to_0x30\n await communicate(joycon, [0x03, 0x30], [[14, 0x03]]);\n // enabling_MCU_data_22_1\n await communicate(\n joycon,\n [0x22, 0x01],\n [\n [13, 0x80],\n [14, 0x22],\n ],",
"score": 12.1199485916118
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // start_external_polling_5A\n await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);\n // blink LED\n await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);\n}\nasync function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {\n await wait<HIDInputReportEvent, void>(\n (resolve) => (event) => {\n if (event.reportId !== 0x21) {\n return;",
"score": 11.04106441046685
}
] | typescript | await setupJoycon(joycon); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = | await getJoyconDevice(); |
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/background/index.ts",
"retrieved_chunk": " if (next === 'content' && payload.kind === 'leaveChargeMode') {\n chrome.tabs.sendMessage(payload.request.senderTabId, msg);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n const sendResponse = (val: any) => {\n const res: CrxRpcResponseMessage = {\n ...msg,",
"score": 19.210732427088956
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 10.620354804500328
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": " case 'openChargeWindow':\n chrome.windows\n .create({\n url: chrome.runtime.getURL('charge.html'),\n type: 'popup',\n })\n .then((res) => {\n const tabId = res.tabs?.[0].id;\n sendResponse(tabId);\n });",
"score": 10.582412007677071
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " if (!device) {\n throw new Error('device not found.');\n }\n if (!device.opened) {\n await device.open();\n }\n await setupJoycon(device);\n return device;\n}\nexport async function setupJoycon(joycon: HIDDevice) {",
"score": 10.498411892563515
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " result.push((value << (outBits - bits)) & maxV);\n }\n } else {\n if (bits >= inBits) return 'Excess padding';\n if ((value << (outBits - bits)) & maxV) return 'Non-zero padding';\n }\n return result;\n}\nexport function isValidHex(hex: string): boolean {\n return /^[a-f0-9]{64}$/.test(hex);",
"score": 8.483615692354299
}
] | typescript | await getJoyconDevice(); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: | generateMessageId(),
src: 'content',
path: ['background'],
payload: { |
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " const messageId = Math.floor(Math.random() * 1000000);\n const message: CrxRpcRequestMessage = {\n ext,\n messageId,\n src: 'nip07-provider',\n path,\n payload: req,\n };\n window.addEventListener('message', listener);\n window.postMessage(message, '*');",
"score": 19.584581596906375
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": " if (next === 'content' && payload.kind === 'leaveChargeMode') {\n chrome.tabs.sendMessage(payload.request.senderTabId, msg);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n const sendResponse = (val: any) => {\n const res: CrxRpcResponseMessage = {\n ...msg,",
"score": 14.101416278405154
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": "// crx-rpc ------------------------------------------------\ntype ExtName = 'nostronger';\ntype CrxRpcMessage = CrxRpcRequestMessage | CrxRpcResponseMessage;\ninterface CrxRpcRequestMessage extends _CrxRpcMessageBase {\n src: CrxMessageOrigin;\n path: CrxMessageOrigin[];\n payload: CrxRpcRequestPayload;\n}\ninterface CrxRpcResponseMessage extends _CrxRpcMessageBase {\n payload: CrxRpcResponsePayload;",
"score": 13.913059797826495
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " data.messageId !== messageId ||\n data.payload.kind !== req.kind ||\n !('response' in data.payload)\n ) {\n return;\n }\n // Assumed by `data.payload.kind !== req.kind`\n const response = data.payload.response as CrxRpcResponse<T> | PromiseLike<CrxRpcResponse<T>>;\n window.removeEventListener('message', listener);\n clearInterval(timeoutId);",
"score": 13.234506605199124
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " msg: CrxRpcRequestMessage,\n origin: CrxMessageOrigin,\n): { next?: CrxMessageOrigin; shouldBeHandled: boolean } {\n if (msg.ext !== 'nostronger' || !('request' in msg.payload) || msg.path[0] !== origin) {\n return {\n shouldBeHandled: false,\n };\n }\n msg.path.shift();\n const next = msg.path[0];",
"score": 10.400381024601275
}
] | typescript | generateMessageId(),
src: 'content',
path: ['background'],
payload: { |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
| await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => { |
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " return wait<HIDInputReportEvent, number>(\n (resolve) => (event) => {\n const strain = getStrain(event);\n if (strain) {\n resolve(strain);\n }\n },\n {\n addEventListener: (listener) => joycon.addEventListener('inputreport', listener),\n removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),",
"score": 23.47522542211614
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'content' -> 'charge'\n kind: 'sendStrain';\n request: {\n value: number;\n neutral: number;\n };\n response: void;",
"score": 15.08276564549328
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " for (let i = 0; i < data.length; ++i) {\n value = (value << inBits) | data[i];\n bits += inBits;\n while (bits >= outBits) {\n bits -= outBits;\n result.push((value >> bits) & maxV);\n }\n }\n if (pad) {\n if (bits > 0) {",
"score": 14.109454882910729
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // start_external_polling_5A\n await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);\n // blink LED\n await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);\n}\nasync function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {\n await wait<HIDInputReportEvent, void>(\n (resolve) => (event) => {\n if (event.reportId !== 0x21) {\n return;",
"score": 12.278015776126102
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " const timeoutId = timeout\n ? setTimeout(() => {\n window.removeEventListener('message', listener);\n reject(`Request \\`${req.kind}\\` timed out`);\n }, timeout)\n : -1;\n function listener(ev: MessageEvent<CrxRpcResponseMessage>) {\n const data = ev.data;\n if (\n data.ext !== 'nostronger' ||",
"score": 12.165149192935633
}
] | typescript | await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => { |
import { wait } from './messaging';
export async function getJoyconDevice() {
const [device] = await navigator.hid.requestDevice({
filters: [
{
vendorId: 0x057e, // Nintendo vendor ID
productId: 0x2007, // joy-con R
},
],
});
if (!device) {
throw new Error('device not found.');
}
if (!device.opened) {
await device.open();
}
await setupJoycon(device);
return device;
}
export async function setupJoycon(joycon: HIDDevice) {
// set_input_report_mode_to_0x30
await communicate(joycon, [0x03, 0x30], [[14, 0x03]]);
// enabling_MCU_data_22_1
await communicate(
joycon,
[0x22, 0x01],
[
[13, 0x80],
[14, 0x22],
],
);
// enabling_MCU_data_21_21_1_1
await communicate(
joycon,
[
0x21, 0x21, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3,
],
[[14, 0x21]],
);
// get_ext_data_59
await communicate(
joycon,
[0x59],
[
[14, 0x59],
[16, 0x20],
],
);
// get_ext_dev_in_format_config_5C
await communicate(
joycon,
[
0x5c, 0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x16, 0xed, 0x34, 0x36, 0x00,
0x00, 0x00, 0x0a, 0x64, 0x0b, 0xe6, 0xa9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x90, 0xa8, 0xe1, 0x34, 0x36,
],
[[14, 0x5c]],
);
// start_external_polling_5A
await communicate(joycon, [0x5a, 0x04, 0x01, 0x01, 0x02], [[14, 0x5a]]);
// blink LED
await communicate(joycon, [0x30, 0x90], [[14, 0x30]]);
}
async function communicate(device: HIDDevice, subcommand: number[], expected: [number, number][]) {
await wait<HIDInputReportEvent, void>(
( | resolve) => (event) => { |
if (event.reportId !== 0x21) {
return;
}
const data = new Uint8Array(event.data.buffer);
if (expected.every(([pos, val]) => data[pos - 1] === val)) {
resolve();
}
},
{
addEventListener: (listener) => device.addEventListener('inputreport', listener),
removeEventListener: (listener) => device.removeEventListener('inputreport', listener),
prepare: () => {
device.sendReport(
0x01,
new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),
);
},
// timeout: 5000,
},
);
}
export async function getNextStrain(joycon: HIDDevice) {
return wait<HIDInputReportEvent, number>(
(resolve) => (event) => {
const strain = getStrain(event);
if (strain) {
resolve(strain);
}
},
{
addEventListener: (listener) => joycon.addEventListener('inputreport', listener),
removeEventListener: (listener) => joycon.removeEventListener('inputreport', listener),
// timeout: 5000,
},
);
}
export function getStrain(event: HIDInputReportEvent) {
if (event.reportId === 0x30) {
return new DataView(event.data.buffer, 38, 2).getInt16(0, true);
} else {
return null;
}
}
| src/lib/ring-con.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/content/index.ts",
"retrieved_chunk": " }\n };\n joycon.addEventListener('inputreport', reportListener);\n // Wait for `leaveChargeMode` signal.\n await wait<CrxRpcRequestMessage, void>(\n (resolve) => (msg) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');\n if (!shouldBeHandled) {\n return;\n }",
"score": 18.14595878968496
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(\n openChargeWindowReq,\n );\n if (result.kind !== 'openChargeWindow') {\n throw 'Unexpected message';\n }\n // Keep sending strain signals.\n const joycon = await getJoyconDevice();\n await setupJoycon(joycon);\n const neutral = await getNextStrain(joycon);",
"score": 17.46088859988189
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": "export async function getSignPower(): Promise<number> {\n const signPower = (await get(LOCAL_STORAGE_KEY.SIGN_POWER)) ?? 0;\n return Number(signPower) || 0;\n}\nexport async function setSignPower(signPower: number) {\n await set(LOCAL_STORAGE_KEY.SIGN_POWER, signPower);\n}",
"score": 16.04764047912745
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": "export const ext: ExtName = 'nostronger';\nexport function generateMessageId() {\n return Math.floor(Math.random() * 1000000);\n}\nexport function wait<E, T>(\n createListener: (resolve: (val: T) => void) => (event: E) => void,\n params: {\n addEventListener: (listener: (event: E) => void) => void;\n removeEventListener: (listener: (event: E) => void) => void;\n prepare?: () => void;",
"score": 13.09058112506774
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": " await chrome.storage.local.set({ [key]: val });\n}\nexport async function getKeyPair(): Promise<KeyPair> {\n const { seckey, pubkey } = await get(LOCAL_STORAGE_KEY.KEY_PAIR);\n return { seckey, pubkey };\n}\nexport async function setKeyPair(seckey: string) {\n const pubkey = await calcPubkey(seckey);\n await set(LOCAL_STORAGE_KEY.KEY_PAIR, { seckey, pubkey });\n}",
"score": 11.531009219307558
}
] | typescript | resolve) => (event) => { |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
src= | {imageSource ? imageSource : blankAvatar} |
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)}
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nexport const StyledImage = styled.img`\n height: 100%;\n width: 100%;\n border-radius: 15px;\n align-self: center;\n`;\nexport const StyledFieldset = styled.fieldset`\n margin: 0;\n padding: 0;",
"score": 9.692589165511778
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " title: 'Cinnamon',\n h1: true,\n isLandingPage: false,\n haveSearchBar: true,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n footerTitle: 'FOOTER TITLE',",
"score": 6.854793999694932
},
{
"filename": "src/utils/authUtils.ts",
"retrieved_chunk": " const { realm_access } = jwtDecode(auth.user.access_token);\n for (const role of roles) {\n if (realm_access.roles?.includes(role) || role === '*') {\n return true;\n }\n }\n }\n return false;\n}\nexport interface KeycloakPayload {",
"score": 6.751076209458408
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 6.707568559392787
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " }}\n >\n <img\n src={itemBulletIcon}\n alt={`${child.title} Icon`}\n />\n </div>\n <div\n style={{\n display: 'flex',",
"score": 6.391949156254585
}
] | typescript | {imageSource ? imageSource : blankAvatar} |
import { UserPopup } from '../components/UserPopup';
import './storiesGlobals.css';
import { testUser } from './sampledata/SampleData';
import { Meta, StoryFn } from '@storybook/react';
import { User } from '../interfaces/index';
import { Dialog } from '../lib-components/Dialog';
import { useState } from 'react';
export default {
title: 'Components/UserPopup',
component: UserPopup,
argTypes: {
user: {
name: 'user',
control: 'object',
description: 'Object which defines user info'
},
logoutMethod: {
name: 'logoutMethod',
type: 'function',
description: 'Function which defines the lougout method for the page'
},
keycloak: {
name: 'keycloak',
description: 'Keycloak instance passed to UserPopup component',
control: { disable: true }
},
accountManagementUrl: {
name: 'accountManagementUrl',
description:
'Url that redirects to account management page of the system',
control: { disable: true }
}
}
} as Meta;
interface UserPopupStory {
user?: User;
}
const Template: StoryFn<UserPopupStory> = ({ user }) => {
const [visibility, setVisibility] = useState<boolean>(false);
return (
<>
<Dialog
type='information'
title='Logout Method '
children='This is a mocked logout. The logout method prop is a method that apply your custom logout to the system.'
acceptLabel='Understood'
visibility={visibility}
setVisibility={setVisibility}
/>
<UserPopup
logoutMethod={() => {
setVisibility(true);
}}
user={user}
auth={undefined}
accountManagementUrl='#'
/>
</>
);
};
export const UserPopup_ = Template.bind({});
UserPopup_.args = {
| user: testUser
}; | src/stories/UserPopup.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " h1={args.h1}\n title={args.title}\n sideMenuLinks={args.sideMenuLinks}\n systemsList={args.systemsListPopup ? args.systemsList : undefined}\n IconComponent={IconComponent}\n />\n </BrowserRouter>\n );\n};\nexport const Navbar_ = Template.bind({});",
"score": 16.94116611576346
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " }\n};\nconst Template: StoryFn<NavbarStoryProps> = (args) => {\n return (\n <BrowserRouter>\n <Navbar\n isLandingPage={args.isLandingPage}\n haveSearchBar={args.haveSearchBar}\n hiddenUser={args.hiddenUser}\n user={args.hiddenUser ? undefined : args.user}",
"score": 16.153412970708043
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " </BrowserRouter>\n );\n};\nexport const SideMenu_ = Template.bind({});\nSideMenu_.args = {\n links: testLinks,\n top: '64px'\n};",
"score": 14.559840893544852
},
{
"filename": "src/stories/SystemsPopup.stories.tsx",
"retrieved_chunk": " return <SystemsPopup systemsList={systemsList} />;\n};\nexport const SystemsList = Template.bind({});\nSystemsList.args = {\n systemsList: testSystems\n};",
"score": 14.196197739748063
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " user: args.hiddenUser ? undefined : args.user,\n h1: args.h1,\n children: undefined,\n title: args.title,\n sideMenuLinks: args.sideMenuLinks,\n systemsList: args.systemsList ? args.systemsList : undefined,\n IconComponent\n }}\n footer={{\n title: args.footerTitle,",
"score": 13.632256084649402
}
] | typescript | user: testUser
}; |
|
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
<HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
);
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
| <StyledDialog
onClose={onHide} |
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " <ScopedCssBaseline>\n <StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>\n {list}\n </StyledDrawer>\n </ScopedCssBaseline>\n </div>\n );\n}",
"score": 9.28232764370091
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " <Divider />\n </List>\n )}\n </div>\n );\n })}\n </ListWrapper>\n );\n return (\n <div>",
"score": 8.21283586027409
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " <div\n style={{\n position: 'absolute',\n left: '45%',\n top: '50%'\n }}\n >\n <Button\n sx={{ bottom: '18px' }}\n onClick={() => setDialogVisibility(!dialogVisibility)}",
"score": 7.610155144768684
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " >\n {drawerVisibility ? 'Close SideMenu' : 'Open SideMenu'}\n </Button>\n </div>\n <SideMenu\n visibility={drawerVisibility}\n setVisibility={setDrawerVisibility}\n links={args.links}\n top={args.top}\n />",
"score": 7.10436167779911
},
{
"filename": "src/lib-components/ImageInput/index.tsx",
"retrieved_chunk": " }\n };\n }\n return (\n <div>\n <StyledFieldset\n onMouseEnter={() => setShowImageInput(true)}\n onMouseLeave={() => setShowImageInput(false)}\n >\n <StyledImage",
"score": 6.333297379379703
}
] | typescript | <StyledDialog
onClose={onHide} |
import { createContext, useEffect, useMemo, useRef, useState } from 'react';
import { MainDiv } from './styles';
import { Navbar, NavbarProps } from '../Navbar/index';
import { Footer, FooterProps } from '../Footer/index';
import { NavbarContextValue } from './useNavbar';
import { ToastContainer } from '../../components/Toast';
export interface PageProps {
navbar?: NavbarProps;
footer?: FooterProps;
children: JSX.Element | JSX.Element[];
centralized?: boolean;
flexDirection?: 'column' | 'column-reverse' | 'row';
haveToast?: boolean;
components?: {
navbar?: JSX.Element;
footer?: JSX.Element;
toastContainer?: JSX.Element;
};
createNavbarContext: boolean;
}
interface Dimensions {
navHeight: number;
footHeight: number;
}
export const NavbarContext = createContext<NavbarContextValue | undefined>(
undefined
);
export function Page({
navbar,
footer,
children,
centralized = false,
flexDirection,
haveToast = false,
components,
createNavbarContext = true
}: PageProps) {
const navbarRef = useRef<HTMLDivElement>(null);
const footerRef = useRef<HTMLDivElement>(null);
const [dimensions, setDimensions] = useState<Dimensions>({
navHeight: 0,
footHeight: 0
});
const firstRender = useRef<boolean>(true);
useEffect(() => {
setDimensions({
navHeight: navbarRef.current ? navbarRef.current.offsetHeight : 0,
footHeight: footerRef.current ? footerRef.current.offsetHeight : 0
});
}, [navbarRef.current?.offsetHeight, footerRef.current?.offsetHeight]);
let diff = navbar ? dimensions.navHeight : 0;
diff += footer ? dimensions.footHeight : 0;
const [navbarProps, setNavbarProps] = useState<NavbarProps>({
...navbar
});
useEffect(() => {
if (createNavbarContext && !firstRender.current) {
setNavbarProps({ ...navbar });
} else {
firstRender.current = false;
}
}, [navbar]);
const navbarContextClass = useMemo(() => {
if (createNavbarContext) {
return new NavbarContextValue({ ...navbarProps }, setNavbarProps);
}
return undefined;
}, [createNavbarContext, navbarProps, setNavbarProps]);
useEffect(() => {
firstRender.current = true;
}, [navbarContextClass]);
return (
<NavbarContext.Provider value={navbarContextClass}>
<div ref={navbarRef} style={{ display: 'inline' }}>
{components?.navbar ? components.navbar : <Navbar {...navbar} />}
</div>
<div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
<MainDiv
style={{
minHeight: `calc(100vh - ${diff}px)`,
alignItems: centralized ? 'center' : 'normal',
justifyContent: centralized ? 'center' : 'normal',
flexDirection: flexDirection ?? 'column',
flexGrow: 1
}}
>
{haveToast &&
(components?.toastContainer ? (
components.toastContainer
) : (
<ToastContainer
toastProps={{
position: 'top-right'
}}
topInitialPosition={dimensions.navHeight}
/>
))}
{children}
</MainDiv>
</div>
<div ref={footerRef} style={{ display: 'inline' }}>
{components?.footer ? components.footer | : <Footer {...footer} />} |
</div>
</NavbarContext.Provider>
);
}
| src/lib-components/Page/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " return (\n <RequireAuth auth={auth} permittedRoles={permittedRoles}>\n <Page\n navbar={navbar}\n footer={footer}\n centralized={centralized}\n haveToast={haveToast}\n components={components}\n createNavbarContext={createNavbarContext}\n >",
"score": 21.830632556026814
},
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " authProps,\n navbar,\n footer,\n centralized = false,\n haveToast = false,\n createNavbarContext = true,\n components,\n children\n}: PageWithAuthProps) {\n const { auth, permittedRoles } = authProps;",
"score": 19.503699689383218
},
{
"filename": "src/lib-components/Page/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nexport const MainDiv = styled.main`\n display: flex;\n padding: 20px clamp(10px, 2%, 40px);\n z-index: 1000;\n background-color: #ffffff;\n`;\nexport const Parent = styled.div`\n display: inline;\n`;",
"score": 16.871753844478786
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " },\n footerLargeFooter: {\n name: 'large footer',\n type: { name: 'boolean', required: false },\n description: 'Boolean which defines if the footer is large or tiny',\n options: [true, false],\n control: { type: 'boolean' },\n table: {\n category: 'Footer'\n }",
"score": 15.173295642597623
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " description: \"String wich defines footer's link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }\n },\n footerTextLink: {\n name: 'text link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's text link\",",
"score": 14.963224375979209
}
] | typescript | : <Footer {...footer} />} |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
< | StyledImage
src={imageSource ? imageSource : blankAvatar} |
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)}
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nexport const StyledImage = styled.img`\n height: 100%;\n width: 100%;\n border-radius: 15px;\n align-self: center;\n`;\nexport const StyledFieldset = styled.fieldset`\n margin: 0;\n padding: 0;",
"score": 9.692589165511778
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " title: 'Cinnamon',\n h1: true,\n isLandingPage: false,\n haveSearchBar: true,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n footerTitle: 'FOOTER TITLE',",
"score": 6.854793999694932
},
{
"filename": "src/utils/authUtils.ts",
"retrieved_chunk": " const { realm_access } = jwtDecode(auth.user.access_token);\n for (const role of roles) {\n if (realm_access.roles?.includes(role) || role === '*') {\n return true;\n }\n }\n }\n return false;\n}\nexport interface KeycloakPayload {",
"score": 6.751076209458408
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 6.707568559392787
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " }}\n >\n <img\n src={itemBulletIcon}\n alt={`${child.title} Icon`}\n />\n </div>\n <div\n style={{\n display: 'flex',",
"score": 6.391949156254585
}
] | typescript | StyledImage
src={imageSource ? imageSource : blankAvatar} |
import { Meta, StoryFn } from '@storybook/react';
import ScopedCssBaseline from '@mui/material/ScopedCssBaseline/ScopedCssBaseline';
import './storiesGlobals.css';
import { Page } from '../lib-components/Page';
import { SideMenuLink, System, User } from '@/interfaces';
import { testLinks, testSystems, testUser } from './sampledata/SampleData';
import { BrowserRouter } from 'react-router-dom';
import EngineeringIcon from '@mui/icons-material/Engineering';
import { JSXElementConstructor } from 'react';
import { footerArgTypes, navbarArgTypes } from './utils/argTypes';
export default {
title: 'Components/Page',
parameters: {
docs: {
page: null
}
},
argTypes: {
navbar: {
table: {
disable: true
}
},
footer: {
table: {
disable: true
}
},
centralized: {
name: 'centralized',
type: { name: 'boolean', required: false },
description:
'Boolean which defines if the content of page is centralized or not.',
options: [true, false],
control: { type: 'boolean' }
},
...footerArgTypes,
...navbarArgTypes,
width: {
name: 'width',
type: { name: 'string', required: false },
description: "String wich defines children's width",
control: { type: 'text' },
table: {
category: 'Children'
}
},
height: {
name: 'height',
type: { name: 'string', required: false },
description: "String wich defines children's height",
control: { type: 'text' },
table: {
category: 'Children'
}
},
color: {
name: 'color',
type: { name: 'string', required: false },
description: "String wich defines children's color",
control: { type: 'color' },
table: {
category: 'Children'
}
}
}
} as Meta;
interface StoryPageProps {
isLandingPage: boolean;
haveSearchBar: boolean;
hiddenUser: boolean;
user: User;
h1: boolean;
sideMenuLinks: SideMenuLink[];
systemsListPopup: boolean;
systemsList: System[];
IconComponent: JSXElementConstructor<any>;
title: string;
footerTitle: string;
footerTelephone: string;
footerTelephoneComplement: string;
footerEmail: string;
footerLink: string;
footerTextLink: string;
footerDescription: string;
footerCopyrightText: string;
width: string;
height: string;
color: string;
centralized: boolean;
}
interface IconComponentProps {
haveIcon: JSXElementConstructor<any>;
}
const IconComponent = ({ haveIcon }: IconComponentProps) => {
if (!haveIcon) {
return <></>;
} else {
return <EngineeringIcon />;
}
};
const Template: StoryFn<StoryPageProps> = (args) => {
return (
<ScopedCssBaseline>
<BrowserRouter>
| <Page
navbar={{ |
isLandingPage: args.isLandingPage,
haveSearchBar: args.haveSearchBar ? true : false,
hiddenUser: args.hiddenUser,
user: args.hiddenUser ? undefined : args.user,
h1: args.h1,
children: undefined,
title: args.title,
sideMenuLinks: args.sideMenuLinks,
systemsList: args.systemsList ? args.systemsList : undefined,
IconComponent
}}
footer={{
title: args.footerTitle,
telephone: args.footerTelephone,
telephoneComplement: args.footerTelephoneComplement,
email: args.footerEmail,
link: args.footerLink,
textLink: args.footerTextLink,
description: args.footerDescription,
copyrightText: args.footerCopyrightText
}}
centralized={args.centralized}
createNavbarContext={false}
>
<div
style={{
width: `${args.width}`,
height: `${args.height}`,
color: `${args.color}`,
backgroundColor: `${args.color}`,
padding: '20px 40px'
}}
></div>
</Page>
</BrowserRouter>
</ScopedCssBaseline>
);
};
export const Page_ = Template.bind({});
Page_.args = {
width: '150px',
height: '150px',
color: '#000000',
title: 'Cinnamon',
h1: true,
isLandingPage: false,
haveSearchBar: true,
hiddenUser: false,
user: testUser,
sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
footerTitle: 'FOOTER TITLE',
footerTelephone: '(xx) xxxx-xxxx',
footerTelephoneComplement: 'Internal number: xxxx / xxxx',
footerEmail: '[email protected]',
footerLink: 'https://www.google.com',
footerTextLink: 'Site',
footerDescription: "Footer's description with \n line break",
footerCopyrightText: 'CIn UFPE | All rights reserved'
};
| src/stories/Page.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " }\n};\nconst Template: StoryFn<NavbarStoryProps> = (args) => {\n return (\n <BrowserRouter>\n <Navbar\n isLandingPage={args.isLandingPage}\n haveSearchBar={args.haveSearchBar}\n hiddenUser={args.hiddenUser}\n user={args.hiddenUser ? undefined : args.user}",
"score": 20.28848295385886
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " links: SideMenuLink[];\n top: string;\n}\nconst Template: StoryFn<SideMenuStoryProps> = (args) => {\n const [drawerVisibility, setDrawerVisibility] = useState<boolean>(false);\n return (\n <BrowserRouter>\n <div\n style={{\n width: '100%',",
"score": 18.37112096065192
},
{
"filename": "src/stories/Footer.stories.tsx",
"retrieved_chunk": " footerDescription: string;\n footerCopyrightText: string;\n footerSignatureText: string;\n footerSignatureLink: string;\n footerLargeFooter: boolean;\n}\nconst Template: StoryFn<FooterStoryProps> = (args) => {\n return (\n <Footer\n title={`${args.footerTitle}`}",
"score": 15.796538908212389
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " iconComponent: JSXElementConstructor<any>;\n}\ninterface IconComponentProps {\n haveIcon: JSXElementConstructor<any>;\n}\nconst IconComponent = ({ haveIcon }: IconComponentProps) => {\n if (!haveIcon) {\n return <></>;\n } else {\n return <EngineeringIcon />;",
"score": 15.676199003713174
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " </BrowserRouter>\n );\n};\nexport const SideMenu_ = Template.bind({});\nSideMenu_.args = {\n links: testLinks,\n top: '64px'\n};",
"score": 13.745264527409358
}
] | typescript | <Page
navbar={{ |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map( | (child) => { |
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SearchDropdown/index.tsx",
"retrieved_chunk": " <SearchDropdownContainer>\n {inputLabelList.map((label, index) => {\n return (\n <Field key={`field_${label + index}`}>\n <DropdownLabel>{label}:</DropdownLabel>\n <DropdownInput\n type='text'\n value={inputList[index]}\n onChange={(e) => handleInputChange(e, index)}\n />",
"score": 10.985484739345747
},
{
"filename": "src/components/SearchDropdown/index.tsx",
"retrieved_chunk": " }, []);\n function handleInputChange(\n e: React.ChangeEvent<HTMLInputElement>,\n index: number\n ) {\n setInputList(\n inputList.map((value, index_map) => {\n if (index === index_map) {\n return e.target.value;\n } else {",
"score": 10.05771178612753
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " id='panel3a-header'\n >\n <Typography>{position.name}</Typography>\n </AccordionSummary>\n </StyledAccordion>\n <Divider />\n </>\n )}\n </div>\n ))}",
"score": 8.2225355784739
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " children: [\n { id: 2, title: 'Register/Edit', href: '#' },\n { id: 3, title: 'List', href: '#' }\n ]\n }\n];\nexport const testUser: User = {\n name: 'Test User',\n email: '[email protected]',\n positions: [",
"score": 7.730699244740851
},
{
"filename": "src/lib-components/Navbar/styles.ts",
"retrieved_chunk": " @media (min-width: 800px) {\n margin-right: auto;\n }\n`;\nexport const SearchBarContainer = styled.div`\n justify-self: center;\n display: flex;\n margin: 0 2rem;\n`;\nexport const Search = styled.div`",
"score": 6.348452004327182
}
] | typescript | (child) => { |
import { StoryFn } from '@storybook/react';
import { Navbar } from '../lib-components/Navbar';
import './storiesGlobals.css';
import { SideMenuLink, System, User } from '@/interfaces';
import { testLinks, testSystems, testUser } from './sampledata/SampleData';
import { BrowserRouter } from 'react-router-dom';
import { JSXElementConstructor } from 'react';
import EngineeringIcon from '@mui/icons-material/Engineering';
import { navbarArgTypes } from './utils/argTypes';
export default {
title: 'Components/Navbar',
parameters: {
docs: {
page: null
}
},
argTypes: {
...navbarArgTypes
}
};
export interface NavbarStoryProps {
isLandingPage: boolean;
haveSearchBar: boolean;
hiddenUser: boolean;
user: User;
h1: boolean;
sideMenuLinks: SideMenuLink[];
systemsListPopup: boolean;
title: string;
systemsList: System[];
iconComponent: JSXElementConstructor<any>;
}
interface IconComponentProps {
haveIcon: JSXElementConstructor<any>;
}
const IconComponent = ({ haveIcon }: IconComponentProps) => {
if (!haveIcon) {
return <></>;
} else {
return <EngineeringIcon />;
}
};
const Template: StoryFn<NavbarStoryProps> = (args) => {
return (
<BrowserRouter>
<Navbar
isLandingPage={args.isLandingPage}
haveSearchBar={args.haveSearchBar}
hiddenUser={args.hiddenUser}
user={args.hiddenUser ? undefined : args.user}
h1={args.h1}
title={args.title}
sideMenuLinks={args.sideMenuLinks}
systemsList={args.systemsListPopup ? args.systemsList : undefined}
IconComponent={IconComponent}
/>
</BrowserRouter>
);
};
export const Navbar_ = Template.bind({});
Navbar_.args = {
h1: true,
isLandingPage: false,
haveSearchBar: false,
hiddenUser: false,
user: testUser,
| sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
iconComponent: () => <></>
}; | src/stories/Navbar.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " title: 'Cinnamon',\n h1: true,\n isLandingPage: false,\n haveSearchBar: true,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n footerTitle: 'FOOTER TITLE',",
"score": 57.740053179279236
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " title = '',\n h1 = false,\n sideMenuLinks = [],\n isLandingPage = false,\n systemsList = [],\n currentSystemIconUrl,\n children,\n IconComponent,\n accountManagementUrl\n}: NavbarProps) => {",
"score": 30.53314309300644
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": "};\nconst Template: StoryFn<StoryPageProps> = (args) => {\n return (\n <ScopedCssBaseline>\n <BrowserRouter>\n <Page\n navbar={{\n isLandingPage: args.isLandingPage,\n haveSearchBar: args.haveSearchBar ? true : false,\n hiddenUser: args.hiddenUser,",
"score": 25.546879296112262
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " auth,\n logoRedirectUrl = '/',\n logoSrc,\n haveSearchBar = false,\n searchFunction = () => {},\n hiddenUser = false,\n user = {\n name: '-',\n email: '-'\n },",
"score": 25.38860059169972
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " },\n if: {\n arg: 'hiddenUser',\n eq: false,\n table: {\n disable: true\n }\n }\n },\n h1: {",
"score": 23.39847198397561
}
] | typescript | sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
iconComponent: () => <></>
}; |
|
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
< | HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
); |
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
<StyledDialog
onClose={onHide}
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " type: 'alert',\n title: 'Alert Message Title',\n children:\n 'DialogAlert is an option to display important information through an alert message, ensuring that the user is aware of a critical information.'\n};\nexport const DialogDecision = TemplateMessage.bind({});\nDialogDecision.args = {\n type: 'decision',\n title: 'Decision Dialog Title',\n children:",
"score": 13.896048222076754
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " );\n } else {\n return <></>;\n }\n}\nexport function SideMenu({\n links,\n top,\n visibility = false,\n setVisibility",
"score": 12.690803516927948
},
{
"filename": "src/lib-components/Dialog/styles.ts",
"retrieved_chunk": "`;\nexport const HeaderBar = styled.div`\n //Componente estilizado correspondente à barrinha com a cor do dialog\n width: 100%;\n height: 2rem;\n background-color: ${(props) => props.color};\n border-top-left-radius: 3px;\n border-top-right-radius: 3px;\n margin-bottom: 1.5rem;\n`;",
"score": 11.8272482833374
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " >\n <div\n style={{\n width: `${args.width}`,\n height: `${args.height}`,\n color: `${args.color}`,\n backgroundColor: `${args.color}`,\n padding: '20px 40px'\n }}\n ></div>",
"score": 11.7756103912599
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " <>\n <Dialog\n type='information'\n title='Logout Method '\n children='This is a mocked logout. The logout method prop is a method that apply your custom logout to the system.'\n acceptLabel='Understood'\n visibility={visibility}\n setVisibility={setVisibility}\n />\n <UserPopup",
"score": 11.278491930639309
}
] | typescript | HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
); |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img | src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{ |
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/IconRender/index.tsx",
"retrieved_chunk": "}: IconRendererProps) {\n return (\n <div style={{ color: 'white', justifyContent: 'center' }}>\n {iconUrl && (\n <img\n style={{ width: '2.35rem', height: '2.35rem', marginLeft: '1.7rem' }}\n src={iconUrl}\n alt={`${alt} icon`}\n />\n )}",
"score": 17.86808089129965
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }, [navbarContextClass]);\n return (\n <NavbarContext.Provider value={navbarContextClass}>\n <div ref={navbarRef} style={{ display: 'inline' }}>\n {components?.navbar ? components.navbar : <Navbar {...navbar} />}\n </div>\n <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>\n <MainDiv\n style={{\n minHeight: `calc(100vh - ${diff}px)`,",
"score": 14.604907963173144
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " margin-top: ${(props) => props.top};\n }\n .MuiPaper-root {\n background-color: #272727;\n min-width: auto;\n overflow: clip;\n }\n`;\nexport const ListWrapper = styled.div`\n width: 250px;",
"score": 12.70347892770333
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />\n </a>\n )}\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>",
"score": 11.737939699054916
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " aria-haspopup='true'\n onClick={handleSystemsMenu}\n color='inherit'\n >\n <SystemsButton>\n <img src={systemsMenuIcon} alt='Systems Menu' />\n </SystemsButton>\n </IconButton>\n <StyledSystemMenu\n id='menu-appbar'",
"score": 10.518103905345736
}
] | typescript | src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{ |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link. | children.map((child) => { |
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SearchDropdown/index.tsx",
"retrieved_chunk": " <SearchDropdownContainer>\n {inputLabelList.map((label, index) => {\n return (\n <Field key={`field_${label + index}`}>\n <DropdownLabel>{label}:</DropdownLabel>\n <DropdownInput\n type='text'\n value={inputList[index]}\n onChange={(e) => handleInputChange(e, index)}\n />",
"score": 10.985484739345747
},
{
"filename": "src/components/SearchDropdown/index.tsx",
"retrieved_chunk": " }, []);\n function handleInputChange(\n e: React.ChangeEvent<HTMLInputElement>,\n index: number\n ) {\n setInputList(\n inputList.map((value, index_map) => {\n if (index === index_map) {\n return e.target.value;\n } else {",
"score": 10.05771178612753
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " id='panel3a-header'\n >\n <Typography>{position.name}</Typography>\n </AccordionSummary>\n </StyledAccordion>\n <Divider />\n </>\n )}\n </div>\n ))}",
"score": 8.2225355784739
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " children: [\n { id: 2, title: 'Register/Edit', href: '#' },\n { id: 3, title: 'List', href: '#' }\n ]\n }\n];\nexport const testUser: User = {\n name: 'Test User',\n email: '[email protected]',\n positions: [",
"score": 7.730699244740851
},
{
"filename": "src/lib-components/Navbar/styles.ts",
"retrieved_chunk": " @media (min-width: 800px) {\n margin-right: auto;\n }\n`;\nexport const SearchBarContainer = styled.div`\n justify-self: center;\n display: flex;\n margin: 0 2rem;\n`;\nexport const Search = styled.div`",
"score": 6.348452004327182
}
] | typescript | children.map((child) => { |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
< | SameTabLink
to={link.href as string} |
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " description: \"String wich defines footer's link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }\n },\n footerTextLink: {\n name: 'text link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's text link\",",
"score": 18.092459815126
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " }\n },\n footerSignatureLink: {\n name: 'signature link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's signature link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }",
"score": 17.030287949662302
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " {email && (\n <a\n href={`mailto:${email}`}\n style={{ color: 'white', zIndex: 3 }}\n >\n {`${email}`}\n </a>\n )}\n <br></br>\n {link && (",
"score": 15.818168695782411
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " link?: string;\n textLink?: string;\n description?: string;\n copyrightText?: string;\n signatureText?: string;\n signatureLink?: string;\n largeFooter?: boolean;\n}\nexport const Footer = ({\n title,",
"score": 15.566795837311837
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " <a href={`${link}`} style={{ color: 'white', zIndex: 3 }}>\n {`${textLink}`}\n </a>\n )}\n </MiddleColumnText>\n </MiddleColumn>\n {description && (\n <RightColumn>\n <RightColumnText>{`${description}`}</RightColumnText>\n </RightColumn>",
"score": 14.785583514190625
}
] | typescript | SameTabLink
to={link.href as string} |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
< | StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list} |
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " </Button>\n </div>\n );\n return (\n <div>\n <StyledDialog\n onClose={onHide}\n aria-labelledby='customized-dialog-title'\n open={visibility}\n sx={{ maxWidth: '100vw' }}",
"score": 17.92904519462775
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " margin-top: ${(props) => props.top};\n }\n .MuiPaper-root {\n background-color: #272727;\n min-width: auto;\n overflow: clip;\n }\n`;\nexport const ListWrapper = styled.div`\n width: 250px;",
"score": 14.690577973216673
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " anchorOrigin={{\n vertical: 'top',\n horizontal: 'right'\n }}\n keepMounted\n transformOrigin={{\n vertical: 'top',\n horizontal: 'right'\n }}\n open={Boolean(anchorUserEl)}",
"score": 13.346117590321207
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " >\n {drawerVisibility ? 'Close SideMenu' : 'Open SideMenu'}\n </Button>\n </div>\n <SideMenu\n visibility={drawerVisibility}\n setVisibility={setDrawerVisibility}\n links={args.links}\n top={args.top}\n />",
"score": 13.21904221725199
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nimport { Drawer } from '@mui/material';\nimport { Link } from 'react-router-dom';\nexport const StyledDrawer = styled(Drawer)<{ top: string }>`\n margin-top: ${(props) => props.top};\n .MuiDrawer-paper {\n margin-top: ${(props) => props.top};\n max-height: calc(100vh - ${(props) => props.top});\n }\n .MuiBackdrop-root {",
"score": 12.832547607475977
}
] | typescript | StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list} |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
| <StyledFieldset
onMouseEnter={() => setShowImageInput(true)} |
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
src={imageSource ? imageSource : blankAvatar}
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)}
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " }, []);\n function toggleChildrenLinks(index: number) {\n if (!showChildrenLinks[index]) {\n setShowChildrenLinks(\n showChildrenLinks.map((value, index_map) => {\n if (index_map === index) {\n return true;\n } else {\n return value;\n }",
"score": 8.41288428748928
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }\n }, [navbar]);\n const navbarContextClass = useMemo(() => {\n if (createNavbarContext) {\n return new NavbarContextValue({ ...navbarProps }, setNavbarProps);\n }\n return undefined;\n }, [createNavbarContext, navbarProps, setNavbarProps]);\n useEffect(() => {\n firstRender.current = true;",
"score": 7.443185824290742
},
{
"filename": "src/utils/authUtils.ts",
"retrieved_chunk": " const { realm_access } = jwtDecode(auth.user.access_token);\n for (const role of roles) {\n if (realm_access.roles?.includes(role) || role === '*') {\n return true;\n }\n }\n }\n return false;\n}\nexport interface KeycloakPayload {",
"score": 6.918731152848865
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " }\n }\n if (auth.isAuthenticated && haveAccess) {\n return children;\n }\n if (auth.isAuthenticated) {\n return (\n <Navigate\n to={`${process.env.PUBLIC_URL}/forbidden`}\n replace",
"score": 6.298570652684965
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " },\n if: {\n arg: 'hiddenUser',\n eq: false,\n table: {\n disable: true\n }\n }\n },\n h1: {",
"score": 6.213475961359524
}
] | typescript | <StyledFieldset
onMouseEnter={() => setShowImageInput(true)} |
import { StoryFn } from '@storybook/react';
import { Navbar } from '../lib-components/Navbar';
import './storiesGlobals.css';
import { SideMenuLink, System, User } from '@/interfaces';
import { testLinks, testSystems, testUser } from './sampledata/SampleData';
import { BrowserRouter } from 'react-router-dom';
import { JSXElementConstructor } from 'react';
import EngineeringIcon from '@mui/icons-material/Engineering';
import { navbarArgTypes } from './utils/argTypes';
export default {
title: 'Components/Navbar',
parameters: {
docs: {
page: null
}
},
argTypes: {
...navbarArgTypes
}
};
export interface NavbarStoryProps {
isLandingPage: boolean;
haveSearchBar: boolean;
hiddenUser: boolean;
user: User;
h1: boolean;
sideMenuLinks: SideMenuLink[];
systemsListPopup: boolean;
title: string;
systemsList: System[];
iconComponent: JSXElementConstructor<any>;
}
interface IconComponentProps {
haveIcon: JSXElementConstructor<any>;
}
const IconComponent = ({ haveIcon }: IconComponentProps) => {
if (!haveIcon) {
return <></>;
} else {
return <EngineeringIcon />;
}
};
const Template: StoryFn<NavbarStoryProps> = (args) => {
return (
<BrowserRouter>
| <Navbar
isLandingPage={args.isLandingPage} |
haveSearchBar={args.haveSearchBar}
hiddenUser={args.hiddenUser}
user={args.hiddenUser ? undefined : args.user}
h1={args.h1}
title={args.title}
sideMenuLinks={args.sideMenuLinks}
systemsList={args.systemsListPopup ? args.systemsList : undefined}
IconComponent={IconComponent}
/>
</BrowserRouter>
);
};
export const Navbar_ = Template.bind({});
Navbar_.args = {
h1: true,
isLandingPage: false,
haveSearchBar: false,
hiddenUser: false,
user: testUser,
sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
iconComponent: () => <></>
};
| src/stories/Navbar.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": "};\nconst Template: StoryFn<StoryPageProps> = (args) => {\n return (\n <ScopedCssBaseline>\n <BrowserRouter>\n <Page\n navbar={{\n isLandingPage: args.isLandingPage,\n haveSearchBar: args.haveSearchBar ? true : false,\n hiddenUser: args.hiddenUser,",
"score": 38.23828692419505
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " links: SideMenuLink[];\n top: string;\n}\nconst Template: StoryFn<SideMenuStoryProps> = (args) => {\n const [drawerVisibility, setDrawerVisibility] = useState<boolean>(false);\n return (\n <BrowserRouter>\n <div\n style={{\n width: '100%',",
"score": 23.311329469354774
},
{
"filename": "src/stories/Footer.stories.tsx",
"retrieved_chunk": " footerDescription: string;\n footerCopyrightText: string;\n footerSignatureText: string;\n footerSignatureLink: string;\n footerLargeFooter: boolean;\n}\nconst Template: StoryFn<FooterStoryProps> = (args) => {\n return (\n <Footer\n title={`${args.footerTitle}`}",
"score": 21.982431791546933
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": "}\ninterface IconComponentProps {\n haveIcon: JSXElementConstructor<any>;\n}\nconst IconComponent = ({ haveIcon }: IconComponentProps) => {\n if (!haveIcon) {\n return <></>;\n } else {\n return <EngineeringIcon />;\n }",
"score": 19.8212690189034
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": "} as Meta;\nconst TemplateMessage: StoryFn<DialogProps> = (args) => {\n const [dialogVisibility, setDialogVisibility] = useState(\n args.visibility ?? false\n );\n useEffect(() => {\n setDialogVisibility(args.visibility ?? false);\n }, [args.visibility]);\n const dialogWithoutFunction = ['alert', 'information'];\n return (",
"score": 19.272861306483037
}
] | typescript | <Navbar
isLandingPage={args.isLandingPage} |
import { createContext, useEffect, useMemo, useRef, useState } from 'react';
import { MainDiv } from './styles';
import { Navbar, NavbarProps } from '../Navbar/index';
import { Footer, FooterProps } from '../Footer/index';
import { NavbarContextValue } from './useNavbar';
import { ToastContainer } from '../../components/Toast';
export interface PageProps {
navbar?: NavbarProps;
footer?: FooterProps;
children: JSX.Element | JSX.Element[];
centralized?: boolean;
flexDirection?: 'column' | 'column-reverse' | 'row';
haveToast?: boolean;
components?: {
navbar?: JSX.Element;
footer?: JSX.Element;
toastContainer?: JSX.Element;
};
createNavbarContext: boolean;
}
interface Dimensions {
navHeight: number;
footHeight: number;
}
export const NavbarContext = createContext<NavbarContextValue | undefined>(
undefined
);
export function Page({
navbar,
footer,
children,
centralized = false,
flexDirection,
haveToast = false,
components,
createNavbarContext = true
}: PageProps) {
const navbarRef = useRef<HTMLDivElement>(null);
const footerRef = useRef<HTMLDivElement>(null);
const [dimensions, setDimensions] = useState<Dimensions>({
navHeight: 0,
footHeight: 0
});
const firstRender = useRef<boolean>(true);
useEffect(() => {
setDimensions({
navHeight: navbarRef.current ? navbarRef.current.offsetHeight : 0,
footHeight: footerRef.current ? footerRef.current.offsetHeight : 0
});
}, [navbarRef.current?.offsetHeight, footerRef.current?.offsetHeight]);
let diff = navbar ? dimensions.navHeight : 0;
diff += footer ? dimensions.footHeight : 0;
const [navbarProps, setNavbarProps] = useState<NavbarProps>({
...navbar
});
useEffect(() => {
if (createNavbarContext && !firstRender.current) {
setNavbarProps({ ...navbar });
} else {
firstRender.current = false;
}
}, [navbar]);
const navbarContextClass = useMemo(() => {
if (createNavbarContext) {
return new NavbarContextValue({ ...navbarProps }, setNavbarProps);
}
return undefined;
}, [createNavbarContext, navbarProps, setNavbarProps]);
useEffect(() => {
firstRender.current = true;
}, [navbarContextClass]);
return (
<NavbarContext.Provider value={navbarContextClass}>
<div ref={navbarRef} style={{ display: 'inline' }}>
{components?.navbar ? components.navbar : <Navbar {...navbar} />}
</div>
<div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
<MainDiv
style={{
minHeight: `calc(100vh - ${diff}px)`,
alignItems: centralized ? 'center' : 'normal',
justifyContent: centralized ? 'center' : 'normal',
flexDirection: flexDirection ?? 'column',
flexGrow: 1
}}
>
{haveToast &&
(components?.toastContainer ? (
components.toastContainer
) : (
< | ToastContainer
toastProps={{ |
position: 'top-right'
}}
topInitialPosition={dimensions.navHeight}
/>
))}
{children}
</MainDiv>
</div>
<div ref={footerRef} style={{ display: 'inline' }}>
{components?.footer ? components.footer : <Footer {...footer} />}
</div>
</NavbarContext.Provider>
);
}
| src/lib-components/Page/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " return (\n <RequireAuth auth={auth} permittedRoles={permittedRoles}>\n <Page\n navbar={navbar}\n footer={footer}\n centralized={centralized}\n haveToast={haveToast}\n components={components}\n createNavbarContext={createNavbarContext}\n >",
"score": 14.920864733119872
},
{
"filename": "src/components/Toast/index.tsx",
"retrieved_chunk": "}\nexport const ToastContainer = ({\n topInitialPosition,\n toastProps\n}: ToastContainerProps) => {\n topInitialPosition = topInitialPosition + 16;\n return (\n <ToastDiv topSpacing={topInitialPosition}>\n <ToastifyContainer {...toastProps} />\n </ToastDiv>",
"score": 13.147865660912874
},
{
"filename": "src/index.ts",
"retrieved_chunk": "export { System } from './interfaces';\nexport { useNavbar } from './lib-components/Page/useNavbar';\nexport { ToastContainer, toast } from './components/Toast';\nexport { IconRenderer } from './lib-components/IconRender';\nexport { PageWithAuth } from './lib-components/PageWithAuth';",
"score": 12.590490373302071
},
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " authProps,\n navbar,\n footer,\n centralized = false,\n haveToast = false,\n createNavbarContext = true,\n components,\n children\n}: PageWithAuthProps) {\n const { auth, permittedRoles } = authProps;",
"score": 11.387951945679553
},
{
"filename": "src/index.ts",
"retrieved_chunk": "export { Navbar } from './lib-components/Navbar';\nexport { Footer } from './lib-components/Footer';\nexport { ImageInput } from './lib-components/ImageInput';\nexport { Dialog } from './lib-components/Dialog';\nexport { Page } from './lib-components/Page';\nexport { RequireAuth } from './lib-components/RequireAuth';\nexport { ForbiddenPage } from './lib-components/ForbiddenPage';\nexport { AuthUtils } from './utils';\nexport { ErrorScreen, httpErrors } from './lib-components/ErrorScreen';\nexport { SideMenuLink } from './interfaces';",
"score": 8.829336982929746
}
] | typescript | ToastContainer
toastProps={{ |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
src={imageSource ? imageSource : blankAvatar}
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
< | StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " {\n id: 1,\n name: 'Position 1',\n roles: [\n {\n id: 1,\n name: 'Role 1',\n description: 'Role 1'\n },\n {",
"score": 13.388435494879765
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " id: 2,\n name: 'Role 2',\n description: 'Role 2'\n }\n ]\n },\n {\n id: 2,\n name: 'Position 2',\n roles: [",
"score": 13.388435494879765
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " {\n id: 1,\n name: 'Role 1',\n description: 'Role 1'\n },\n {\n id: 2,\n name: 'Role 2',\n description: 'Role 2'\n }",
"score": 12.961854959456742
},
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": " display: flex;\n align-items: center;\n justify-content: center;\n cursor: pointer;\n`;\nexport const StyledSpan = styled.span`\n color: #ffffff;\n font-size: 1.5rem;\n text-align: center;\n`;",
"score": 12.252358104742328
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": " return (\n <div style={{ width: '10rem', padding: '1rem' }}>\n <ImageInput setFile={setFile} id='image-input-test' />\n <div\n style={{\n width: '10rem',\n display: 'flex',\n flexDirection: 'column',\n textAlign: 'center',\n paddingTop: '4rem'",
"score": 12.191762251889745
}
] | typescript | StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
import { createContext, useEffect, useMemo, useRef, useState } from 'react';
import { MainDiv } from './styles';
import { Navbar, NavbarProps } from '../Navbar/index';
import { Footer, FooterProps } from '../Footer/index';
import { NavbarContextValue } from './useNavbar';
import { ToastContainer } from '../../components/Toast';
export interface PageProps {
navbar?: NavbarProps;
footer?: FooterProps;
children: JSX.Element | JSX.Element[];
centralized?: boolean;
flexDirection?: 'column' | 'column-reverse' | 'row';
haveToast?: boolean;
components?: {
navbar?: JSX.Element;
footer?: JSX.Element;
toastContainer?: JSX.Element;
};
createNavbarContext: boolean;
}
interface Dimensions {
navHeight: number;
footHeight: number;
}
export const NavbarContext = createContext<NavbarContextValue | undefined>(
undefined
);
export function Page({
navbar,
footer,
children,
centralized = false,
flexDirection,
haveToast = false,
components,
createNavbarContext = true
}: PageProps) {
const navbarRef = useRef<HTMLDivElement>(null);
const footerRef = useRef<HTMLDivElement>(null);
const [dimensions, setDimensions] = useState<Dimensions>({
navHeight: 0,
footHeight: 0
});
const firstRender = useRef<boolean>(true);
useEffect(() => {
setDimensions({
navHeight: navbarRef.current ? navbarRef.current.offsetHeight : 0,
footHeight: footerRef.current ? footerRef.current.offsetHeight : 0
});
}, [navbarRef.current?.offsetHeight, footerRef.current?.offsetHeight]);
let diff = navbar ? dimensions.navHeight : 0;
diff += footer ? dimensions.footHeight : 0;
const [navbarProps, setNavbarProps] = useState<NavbarProps>({
...navbar
});
useEffect(() => {
if (createNavbarContext && !firstRender.current) {
setNavbarProps({ ...navbar });
} else {
firstRender.current = false;
}
}, [navbar]);
const navbarContextClass = useMemo(() => {
if (createNavbarContext) {
return new NavbarContextValue({ ...navbarProps }, setNavbarProps);
}
return undefined;
}, [createNavbarContext, navbarProps, setNavbarProps]);
useEffect(() => {
firstRender.current = true;
}, [navbarContextClass]);
return (
<NavbarContext.Provider value={navbarContextClass}>
<div ref={navbarRef} style={{ display: 'inline' }}>
{components?.navbar ? components.navbar : <Navbar {...navbar} />}
</div>
<div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
| <MainDiv
style={{ |
minHeight: `calc(100vh - ${diff}px)`,
alignItems: centralized ? 'center' : 'normal',
justifyContent: centralized ? 'center' : 'normal',
flexDirection: flexDirection ?? 'column',
flexGrow: 1
}}
>
{haveToast &&
(components?.toastContainer ? (
components.toastContainer
) : (
<ToastContainer
toastProps={{
position: 'top-right'
}}
topInitialPosition={dimensions.navHeight}
/>
))}
{children}
</MainDiv>
</div>
<div ref={footerRef} style={{ display: 'inline' }}>
{components?.footer ? components.footer : <Footer {...footer} />}
</div>
</NavbarContext.Provider>
);
}
| src/lib-components/Page/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": " return (\n <div style={{ width: '10rem', padding: '1rem' }}>\n <ImageInput setFile={setFile} id='image-input-test' />\n <div\n style={{\n width: '10rem',\n display: 'flex',\n flexDirection: 'column',\n textAlign: 'center',\n paddingTop: '4rem'",
"score": 29.146442307362758
},
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " return (\n <RequireAuth auth={auth} permittedRoles={permittedRoles}>\n <Page\n navbar={navbar}\n footer={footer}\n centralized={centralized}\n haveToast={haveToast}\n components={components}\n createNavbarContext={createNavbarContext}\n >",
"score": 24.859675111632313
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " <div\n style={{\n display: 'flex',\n justifyContent: 'center',\n minHeight: '100%',\n overflow: 'clip',\n flexWrap: 'nowrap'\n }}\n >\n <img",
"score": 22.710080927037787
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " <div\n style={{\n display: 'flex',\n justifyContent: 'left',\n minWidth: '80%'\n }}\n >\n {child.title}\n </div>\n </NewTabLink>",
"score": 22.233601343062055
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " IconComponent={link.IconComponent}\n />\n </div>\n <div\n style={{\n display: 'flex',\n justifyContent: 'left',\n minWidth: '78%'\n }}\n >",
"score": 22.233601343062055
}
] | typescript | <MainDiv
style={{ |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
| <ListWrapper
style={{ |
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": "export const Dialog = ({\n type,\n title,\n children,\n visibility = false,\n setVisibility,\n acceptLabel = 'Ok',\n rejectLabel = 'Cancelar',\n acceptFunction,\n rejectFunction",
"score": 9.244881050544889
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " setVisibility(!visibility);\n }\n const header = (\n <div>\n <HeaderBar color={color[type]} />\n <Title>{title}</Title>\n </div>\n );\n const dialogFooter =\n type === 'information' || type === 'alert' ? (",
"score": 8.989854248388813
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " control: { disable: true }\n }\n }\n} as Meta;\ninterface UserPopupStory {\n user?: User;\n}\nconst Template: StoryFn<UserPopupStory> = ({ user }) => {\n const [visibility, setVisibility] = useState<boolean>(false);\n return (",
"score": 8.64511532583587
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " },\n setVisibility: {\n name: 'setVisibility',\n control: { disable: true },\n description:\n 'useState set function passed to define the visibility of sidemenu in actions.',\n table: {\n category: 'SideMenu'\n }\n },",
"score": 8.164976988363582
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " >\n Show Dialog\n </Button>\n {dialogWithoutFunction.includes(args.type) ? (\n <Dialog\n {...args}\n visibility={dialogVisibility}\n setVisibility={setDialogVisibility}\n />\n ) : (",
"score": 8.1533874751613
}
] | typescript | <ListWrapper
style={{ |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
| <SameTabLink
to={link.href as string} |
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " description: \"String wich defines footer's link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }\n },\n footerTextLink: {\n name: 'text link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's text link\",",
"score": 29.087291762640092
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " }\n },\n footerSignatureLink: {\n name: 'signature link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's signature link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }",
"score": 27.170457111309908
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " {email && (\n <a\n href={`mailto:${email}`}\n style={{ color: 'white', zIndex: 3 }}\n >\n {`${email}`}\n </a>\n )}\n <br></br>\n {link && (",
"score": 24.232236243737788
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " link?: string;\n textLink?: string;\n description?: string;\n copyrightText?: string;\n signatureText?: string;\n signatureLink?: string;\n largeFooter?: boolean;\n}\nexport const Footer = ({\n title,",
"score": 23.43160628515501
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " telephone,\n telephoneComplement,\n email,\n link,\n textLink,\n description,\n copyrightText,\n signatureText,\n signatureLink,\n largeFooter = true",
"score": 23.19500403952645
}
] | typescript | <SameTabLink
to={link.href as string} |
import { StoryFn } from '@storybook/react';
import { Navbar } from '../lib-components/Navbar';
import './storiesGlobals.css';
import { SideMenuLink, System, User } from '@/interfaces';
import { testLinks, testSystems, testUser } from './sampledata/SampleData';
import { BrowserRouter } from 'react-router-dom';
import { JSXElementConstructor } from 'react';
import EngineeringIcon from '@mui/icons-material/Engineering';
import { navbarArgTypes } from './utils/argTypes';
export default {
title: 'Components/Navbar',
parameters: {
docs: {
page: null
}
},
argTypes: {
...navbarArgTypes
}
};
export interface NavbarStoryProps {
isLandingPage: boolean;
haveSearchBar: boolean;
hiddenUser: boolean;
user: User;
h1: boolean;
sideMenuLinks: SideMenuLink[];
systemsListPopup: boolean;
title: string;
systemsList: System[];
iconComponent: JSXElementConstructor<any>;
}
interface IconComponentProps {
haveIcon: JSXElementConstructor<any>;
}
const IconComponent = ({ haveIcon }: IconComponentProps) => {
if (!haveIcon) {
return <></>;
} else {
return <EngineeringIcon />;
}
};
const Template: StoryFn<NavbarStoryProps> = (args) => {
return (
<BrowserRouter>
<Navbar
isLandingPage={args.isLandingPage}
haveSearchBar={args.haveSearchBar}
hiddenUser={args.hiddenUser}
user={args.hiddenUser ? undefined : args.user}
h1={args.h1}
title={args.title}
sideMenuLinks={args.sideMenuLinks}
systemsList={args.systemsListPopup ? args.systemsList : undefined}
IconComponent={IconComponent}
/>
</BrowserRouter>
);
};
export const Navbar_ = Template.bind({});
Navbar_.args = {
h1: true,
isLandingPage: false,
haveSearchBar: false,
hiddenUser: false,
user: testUser,
sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: | testSystems,
iconComponent: () => <></>
}; | src/stories/Navbar.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " title: 'Cinnamon',\n h1: true,\n isLandingPage: false,\n haveSearchBar: true,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n footerTitle: 'FOOTER TITLE',",
"score": 50.87302610848717
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " title = '',\n h1 = false,\n sideMenuLinks = [],\n isLandingPage = false,\n systemsList = [],\n currentSystemIconUrl,\n children,\n IconComponent,\n accountManagementUrl\n}: NavbarProps) => {",
"score": 26.180301231554598
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " auth,\n logoRedirectUrl = '/',\n logoSrc,\n haveSearchBar = false,\n searchFunction = () => {},\n hiddenUser = false,\n user = {\n name: '-',\n email: '-'\n },",
"score": 25.38860059169972
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": "};\nconst Template: StoryFn<StoryPageProps> = (args) => {\n return (\n <ScopedCssBaseline>\n <BrowserRouter>\n <Page\n navbar={{\n isLandingPage: args.isLandingPage,\n haveSearchBar: args.haveSearchBar ? true : false,\n hiddenUser: args.hiddenUser,",
"score": 23.20054706973337
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " category: 'Navbar'\n }\n },\n hiddenUser: {\n name: 'hiddenUser',\n type: { name: 'boolean', required: false },\n description: 'Boolean which defines if the navbar hides the user.',\n options: [true, false],\n control: { type: 'boolean' },\n table: {",
"score": 17.390092286916783
}
] | typescript | testSystems,
iconComponent: () => <></>
}; |
|
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
<HeaderBar color={color[type]} />
| <Title>{title}</Title>
</div>
); |
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
<StyledDialog
onClose={onHide}
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " type: 'alert',\n title: 'Alert Message Title',\n children:\n 'DialogAlert is an option to display important information through an alert message, ensuring that the user is aware of a critical information.'\n};\nexport const DialogDecision = TemplateMessage.bind({});\nDialogDecision.args = {\n type: 'decision',\n title: 'Decision Dialog Title',\n children:",
"score": 13.896048222076754
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " );\n } else {\n return <></>;\n }\n}\nexport function SideMenu({\n links,\n top,\n visibility = false,\n setVisibility",
"score": 12.690803516927948
},
{
"filename": "src/lib-components/Dialog/styles.ts",
"retrieved_chunk": "`;\nexport const HeaderBar = styled.div`\n //Componente estilizado correspondente à barrinha com a cor do dialog\n width: 100%;\n height: 2rem;\n background-color: ${(props) => props.color};\n border-top-left-radius: 3px;\n border-top-right-radius: 3px;\n margin-bottom: 1.5rem;\n`;",
"score": 11.8272482833374
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " >\n <div\n style={{\n width: `${args.width}`,\n height: `${args.height}`,\n color: `${args.color}`,\n backgroundColor: `${args.color}`,\n padding: '20px 40px'\n }}\n ></div>",
"score": 11.7756103912599
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " <>\n <Dialog\n type='information'\n title='Logout Method '\n children='This is a mocked logout. The logout method prop is a method that apply your custom logout to the system.'\n acceptLabel='Understood'\n visibility={visibility}\n setVisibility={setVisibility}\n />\n <UserPopup",
"score": 11.278491930639309
}
] | typescript | <Title>{title}</Title>
</div>
); |
import { useEffect, useState } from 'react';
import forbidden_403 from '../../assets/icons/forbidden_403.svg';
import { Button, Avatar } from '@mui/material';
import LogoutIcon from '@mui/icons-material/Logout';
import { useLocation, useNavigate, To } from 'react-router-dom';
import { AuthContextProps } from 'react-oidc-context';
import {
ErrorImg,
MediumText,
EmailText,
EmailContainer,
PageContent
} from './styles';
export interface ForbiddenPageProps {
auth?: AuthContextProps;
}
interface Location {
pathname: string;
state: {
from: {
pathname: string;
};
};
}
export const ForbiddenPage = ({ auth }: ForbiddenPageProps) => {
const email = auth?.user?.profile.email;
const [from, setFrom] = useState<string>();
const navigate = useNavigate();
const location = useLocation() as Location;
useEffect(() => {
if (location.state?.from !== undefined) {
setFrom(location.state.from.pathname);
} else {
navigate(process.env.PUBLIC_URL as To);
}
}, []);
const logout = async () => {
await auth?.signoutRedirect({
post_logout_redirect_uri: `${window.location.origin}/${from}`
});
};
return (
<PageContent>
<ErrorImg
src | ={forbidden_403} |
alt='Imagem indicando erro 403 - Acesso negado'
/>
<MediumText>You are logged in as:</MediumText>
<EmailContainer>
<Avatar src='/broken-image.jpg' />
<EmailText>{email}</EmailText>
</EmailContainer>
<Button
sx={{
marginTop: '1.5vh',
color: '#000000',
backgroundColor: '#FFFFFF',
borderRadius: '100vh',
borderColor: '#DADADA',
'&:hover': {
backgroundColor: '#DADADA',
borderColor: '#DADADA'
}
}}
onClick={logout}
variant='outlined'
startIcon={<LogoutIcon />}
>
Log out
</Button>
</PageContent>
);
};
| src/lib-components/ForbiddenPage/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " state={{ from: location }}\n />\n );\n }\n setTimeout(() => auth.signinRedirect(), 500);\n return (\n <Box\n minHeight='100vh'\n display='flex'\n alignItems='center'",
"score": 13.222374674893803
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " const {\n user = { name: 'User Display Name', email: '[email protected]' },\n logoutMethod,\n auth,\n accountManagementUrl\n } = props;\n function logoutFunction() {\n logoutMethod ? logoutMethod() : auth?.signoutRedirect();\n }\n return (",
"score": 12.082060797291062
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " <ErrorImg\n src={notFound_404}\n alt='Imagem indicando erro 404 - Página não encontrada'\n />\n </NotFoundWrapper>\n );\n};\nconst ComingSoon = () => {\n return (\n <ComingSoonWrapper>",
"score": 10.973536378133739
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " async function load() {\n if (auth) {\n setProfile({\n name: auth.user?.profile?.given_name ?? '',\n email: auth.user?.profile?.email ?? '',\n username: auth.user?.profile?.preferred_username ?? '',\n });\n }\n }\n load();",
"score": 10.304307286086864
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " <LargeText>\n Você tentou acessar uma página <br /> ainda em construção.\n </LargeText>\n <ErrorImg src={comingSoon_501} alt='Imagem indicando erro 501' />\n </ComingSoonWrapper>\n );\n};\nconst Inactive = () => {\n return (\n <InactiveWrapper>",
"score": 9.255609854269096
}
] | typescript | ={forbidden_403} |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
| <img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{ |
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/IconRender/index.tsx",
"retrieved_chunk": "}: IconRendererProps) {\n return (\n <div style={{ color: 'white', justifyContent: 'center' }}>\n {iconUrl && (\n <img\n style={{ width: '2.35rem', height: '2.35rem', marginLeft: '1.7rem' }}\n src={iconUrl}\n alt={`${alt} icon`}\n />\n )}",
"score": 23.635395034967946
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 14.664362218734109
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }, [navbarContextClass]);\n return (\n <NavbarContext.Provider value={navbarContextClass}>\n <div ref={navbarRef} style={{ display: 'inline' }}>\n {components?.navbar ? components.navbar : <Navbar {...navbar} />}\n </div>\n <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>\n <MainDiv\n style={{\n minHeight: `calc(100vh - ${diff}px)`,",
"score": 14.604907963173144
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " display='flex'\n alignItems='center'\n justifyContent='center'\n >\n <h3>\n Não foi possível estabelecer conexão com a página, tente novamente\n mais tarde.\n </h3>\n <img\n src={wcBackground}",
"score": 13.802694659862077
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " margin-top: ${(props) => props.top};\n }\n .MuiPaper-root {\n background-color: #272727;\n min-width: auto;\n overflow: clip;\n }\n`;\nexport const ListWrapper = styled.div`\n width: 250px;",
"score": 12.70347892770333
}
] | typescript | <img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{ |
import { useState } from 'react';
import { SideMenu } from '../components/SideMenu';
import { BrowserRouter } from 'react-router-dom';
import { Meta, StoryFn } from '@storybook/react';
import { testLinks } from './sampledata/SampleData';
import { SideMenuLink } from '../interfaces';
import { Button } from '@mui/material';
export default {
title: 'Components/SideMenu',
component: SideMenu,
parameters: {
docs: {
page: null
}
},
argTypes: {
visibility: {
name: 'visibility',
control: { disable: true },
description: 'Boolean which defines the visibility of sidemenu.',
table: {
category: 'SideMenu'
}
},
top: {
name: 'top',
description: 'Top spacing of sidemenu to top of your page.',
table: {
category: 'SideMenu'
}
},
setVisibility: {
name: 'setVisibility',
control: { disable: true },
description:
'useState set function passed to define the visibility of sidemenu in actions.',
table: {
category: 'SideMenu'
}
},
links: {
name: 'links',
description: 'Array of links which defines the custom side menu',
table: {
category: 'SideMenu'
}
}
}
} as Meta;
interface SideMenuStoryProps {
links: SideMenuLink[];
top: string;
}
const Template: StoryFn<SideMenuStoryProps> = (args) => {
const [drawerVisibility, setDrawerVisibility] = useState<boolean>(false);
return (
<BrowserRouter>
<div
style={{
width: '100%',
height: '64px',
display: 'flex',
justifyContent: 'center',
alignItems: 'center'
}}
>
<Button
type='button'
variant='contained'
onClick={() => setDrawerVisibility(!drawerVisibility)}
>
{drawerVisibility ? 'Close SideMenu' : 'Open SideMenu'}
</Button>
</div>
<SideMenu
visibility={drawerVisibility}
setVisibility={setDrawerVisibility}
links={args.links}
top={args.top}
/>
</BrowserRouter>
);
};
export const SideMenu_ = Template.bind({});
SideMenu_.args = {
| links: testLinks,
top: '64px'
}; | src/stories/SideMenu.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " h1={args.h1}\n title={args.title}\n sideMenuLinks={args.sideMenuLinks}\n systemsList={args.systemsListPopup ? args.systemsList : undefined}\n IconComponent={IconComponent}\n />\n </BrowserRouter>\n );\n};\nexport const Navbar_ = Template.bind({});",
"score": 23.219695947121366
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " </StyledToolbar>\n </StyledAppBar>\n {children !== undefined ? (\n children\n ) : (\n <SideMenu\n visibility={sideMenuIsOpen}\n top={'64px'}\n setVisibility={handleToggleSideMenu}\n links={sideMenuLinks}",
"score": 21.37449449056588
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " </Page>\n </BrowserRouter>\n </ScopedCssBaseline>\n );\n};\nexport const Page_ = Template.bind({});\nPage_.args = {\n width: '150px',\n height: '150px',\n color: '#000000',",
"score": 20.852145394325248
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": "export const UserPopup_ = Template.bind({});\nUserPopup_.args = {\n user: testUser\n};",
"score": 19.7599891046891
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " }\n};\nconst Template: StoryFn<NavbarStoryProps> = (args) => {\n return (\n <BrowserRouter>\n <Navbar\n isLandingPage={args.isLandingPage}\n haveSearchBar={args.haveSearchBar}\n hiddenUser={args.hiddenUser}\n user={args.hiddenUser ? undefined : args.user}",
"score": 19.24517613803743
}
] | typescript | links: testLinks,
top: '64px'
}; |
|
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
| <HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
); |
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
<StyledDialog
onClose={onHide}
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " type: 'alert',\n title: 'Alert Message Title',\n children:\n 'DialogAlert is an option to display important information through an alert message, ensuring that the user is aware of a critical information.'\n};\nexport const DialogDecision = TemplateMessage.bind({});\nDialogDecision.args = {\n type: 'decision',\n title: 'Decision Dialog Title',\n children:",
"score": 13.896048222076754
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " );\n } else {\n return <></>;\n }\n}\nexport function SideMenu({\n links,\n top,\n visibility = false,\n setVisibility",
"score": 12.690803516927948
},
{
"filename": "src/lib-components/Dialog/styles.ts",
"retrieved_chunk": "`;\nexport const HeaderBar = styled.div`\n //Componente estilizado correspondente à barrinha com a cor do dialog\n width: 100%;\n height: 2rem;\n background-color: ${(props) => props.color};\n border-top-left-radius: 3px;\n border-top-right-radius: 3px;\n margin-bottom: 1.5rem;\n`;",
"score": 11.8272482833374
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " >\n <div\n style={{\n width: `${args.width}`,\n height: `${args.height}`,\n color: `${args.color}`,\n backgroundColor: `${args.color}`,\n padding: '20px 40px'\n }}\n ></div>",
"score": 11.7756103912599
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " <>\n <Dialog\n type='information'\n title='Logout Method '\n children='This is a mocked logout. The logout method prop is a method that apply your custom logout to the system.'\n acceptLabel='Understood'\n visibility={visibility}\n setVisibility={setVisibility}\n />\n <UserPopup",
"score": 11.278491930639309
}
] | typescript | <HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
); |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
| <NewTabLink
style={{ minHeight: '54px' }} |
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/Page/useNavbar.ts",
"retrieved_chunk": " }\n}\nexport const useNavbar = (): NavbarContextValue | undefined => {\n const contextValue: NavbarContextValue | undefined =\n useContext(NavbarContext);\n if (!contextValue) {\n throw new Error('Navbar context not available.');\n }\n return contextValue;\n};",
"score": 21.07573859520346
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " description: \"String wich defines footer's link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }\n },\n footerTextLink: {\n name: 'text link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's text link\",",
"score": 16.492247921271144
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " {email && (\n <a\n href={`mailto:${email}`}\n style={{ color: 'white', zIndex: 3 }}\n >\n {`${email}`}\n </a>\n )}\n <br></br>\n {link && (",
"score": 15.818168695782411
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " }\n },\n footerSignatureLink: {\n name: 'signature link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's signature link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }",
"score": 15.210253742471403
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }\n }, [navbar]);\n const navbarContextClass = useMemo(() => {\n if (createNavbarContext) {\n return new NavbarContextValue({ ...navbarProps }, setNavbarProps);\n }\n return undefined;\n }, [createNavbarContext, navbarProps, setNavbarProps]);\n useEffect(() => {\n firstRender.current = true;",
"score": 14.985647915617683
}
] | typescript | <NewTabLink
style={{ minHeight: '54px' }} |
import { createContext, useEffect, useMemo, useRef, useState } from 'react';
import { MainDiv } from './styles';
import { Navbar, NavbarProps } from '../Navbar/index';
import { Footer, FooterProps } from '../Footer/index';
import { NavbarContextValue } from './useNavbar';
import { ToastContainer } from '../../components/Toast';
export interface PageProps {
navbar?: NavbarProps;
footer?: FooterProps;
children: JSX.Element | JSX.Element[];
centralized?: boolean;
flexDirection?: 'column' | 'column-reverse' | 'row';
haveToast?: boolean;
components?: {
navbar?: JSX.Element;
footer?: JSX.Element;
toastContainer?: JSX.Element;
};
createNavbarContext: boolean;
}
interface Dimensions {
navHeight: number;
footHeight: number;
}
export const NavbarContext = createContext<NavbarContextValue | undefined>(
undefined
);
export function Page({
navbar,
footer,
children,
centralized = false,
flexDirection,
haveToast = false,
components,
createNavbarContext = true
}: PageProps) {
const navbarRef = useRef<HTMLDivElement>(null);
const footerRef = useRef<HTMLDivElement>(null);
const [dimensions, setDimensions] = useState<Dimensions>({
navHeight: 0,
footHeight: 0
});
const firstRender = useRef<boolean>(true);
useEffect(() => {
setDimensions({
navHeight: navbarRef.current ? navbarRef.current.offsetHeight : 0,
footHeight: footerRef.current ? footerRef.current.offsetHeight : 0
});
}, [navbarRef.current?.offsetHeight, footerRef.current?.offsetHeight]);
let diff = navbar ? dimensions.navHeight : 0;
diff += footer ? dimensions.footHeight : 0;
const [navbarProps, setNavbarProps] = useState<NavbarProps>({
...navbar
});
useEffect(() => {
if (createNavbarContext && !firstRender.current) {
setNavbarProps({ ...navbar });
} else {
firstRender.current = false;
}
}, [navbar]);
const navbarContextClass = useMemo(() => {
if (createNavbarContext) {
return new NavbarContextValue({ ...navbarProps }, setNavbarProps);
}
return undefined;
}, [createNavbarContext, navbarProps, setNavbarProps]);
useEffect(() => {
firstRender.current = true;
}, [navbarContextClass]);
return (
<NavbarContext.Provider value={navbarContextClass}>
<div ref={navbarRef} style={{ display: 'inline' }}>
| {components?.navbar ? components.navbar : <Navbar {...navbar} />} |
</div>
<div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
<MainDiv
style={{
minHeight: `calc(100vh - ${diff}px)`,
alignItems: centralized ? 'center' : 'normal',
justifyContent: centralized ? 'center' : 'normal',
flexDirection: flexDirection ?? 'column',
flexGrow: 1
}}
>
{haveToast &&
(components?.toastContainer ? (
components.toastContainer
) : (
<ToastContainer
toastProps={{
position: 'top-right'
}}
topInitialPosition={dimensions.navHeight}
/>
))}
{children}
</MainDiv>
</div>
<div ref={footerRef} style={{ display: 'inline' }}>
{components?.footer ? components.footer : <Footer {...footer} />}
</div>
</NavbarContext.Provider>
);
}
| src/lib-components/Page/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " return (\n <RequireAuth auth={auth} permittedRoles={permittedRoles}>\n <Page\n navbar={navbar}\n footer={footer}\n centralized={centralized}\n haveToast={haveToast}\n components={components}\n createNavbarContext={createNavbarContext}\n >",
"score": 33.776931579129204
},
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " authProps,\n navbar,\n footer,\n centralized = false,\n haveToast = false,\n createNavbarContext = true,\n components,\n children\n}: PageWithAuthProps) {\n const { auth, permittedRoles } = authProps;",
"score": 25.47955387936677
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": "};\nconst Template: StoryFn<StoryPageProps> = (args) => {\n return (\n <ScopedCssBaseline>\n <BrowserRouter>\n <Page\n navbar={{\n isLandingPage: args.isLandingPage,\n haveSearchBar: args.haveSearchBar ? true : false,\n hiddenUser: args.hiddenUser,",
"score": 16.710729018884415
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " table: {\n category: 'Navbar'\n }\n },\n iconComponent: {\n name: 'iconComponent',\n description: 'Icon of system that appears in navbar',\n table: {\n category: 'Navbar'\n }",
"score": 16.36978230360515
},
{
"filename": "src/lib-components/Page/useNavbar.ts",
"retrieved_chunk": " }\n}\nexport const useNavbar = (): NavbarContextValue | undefined => {\n const contextValue: NavbarContextValue | undefined =\n useContext(NavbarContext);\n if (!contextValue) {\n throw new Error('Navbar context not available.');\n }\n return contextValue;\n};",
"score": 15.70172594788049
}
] | typescript | {components?.navbar ? components.navbar : <Navbar {...navbar} />} |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
< | ListWrapper
style={{ |
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": "export const Dialog = ({\n type,\n title,\n children,\n visibility = false,\n setVisibility,\n acceptLabel = 'Ok',\n rejectLabel = 'Cancelar',\n acceptFunction,\n rejectFunction",
"score": 9.244881050544889
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " setVisibility(!visibility);\n }\n const header = (\n <div>\n <HeaderBar color={color[type]} />\n <Title>{title}</Title>\n </div>\n );\n const dialogFooter =\n type === 'information' || type === 'alert' ? (",
"score": 8.989854248388813
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " control: { disable: true }\n }\n }\n} as Meta;\ninterface UserPopupStory {\n user?: User;\n}\nconst Template: StoryFn<UserPopupStory> = ({ user }) => {\n const [visibility, setVisibility] = useState<boolean>(false);\n return (",
"score": 8.64511532583587
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " },\n setVisibility: {\n name: 'setVisibility',\n control: { disable: true },\n description:\n 'useState set function passed to define the visibility of sidemenu in actions.',\n table: {\n category: 'SideMenu'\n }\n },",
"score": 8.164976988363582
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " >\n Show Dialog\n </Button>\n {dialogWithoutFunction.includes(args.type) ? (\n <Dialog\n {...args}\n visibility={dialogVisibility}\n setVisibility={setDialogVisibility}\n />\n ) : (",
"score": 8.1533874751613
}
] | typescript | ListWrapper
style={{ |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
src={imageSource ? imageSource : blankAvatar}
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
< | StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " {\n id: 1,\n name: 'Position 1',\n roles: [\n {\n id: 1,\n name: 'Role 1',\n description: 'Role 1'\n },\n {",
"score": 13.388435494879765
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " id: 2,\n name: 'Role 2',\n description: 'Role 2'\n }\n ]\n },\n {\n id: 2,\n name: 'Position 2',\n roles: [",
"score": 13.388435494879765
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " {\n id: 1,\n name: 'Role 1',\n description: 'Role 1'\n },\n {\n id: 2,\n name: 'Role 2',\n description: 'Role 2'\n }",
"score": 12.961854959456742
},
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": " display: flex;\n align-items: center;\n justify-content: center;\n cursor: pointer;\n`;\nexport const StyledSpan = styled.span`\n color: #ffffff;\n font-size: 1.5rem;\n text-align: center;\n`;",
"score": 12.252358104742328
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": " return (\n <div style={{ width: '10rem', padding: '1rem' }}>\n <ImageInput setFile={setFile} id='image-input-test' />\n <div\n style={{\n width: '10rem',\n display: 'flex',\n flexDirection: 'column',\n textAlign: 'center',\n paddingTop: '4rem'",
"score": 12.191762251889745
}
] | typescript | StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
<HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
);
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
< | StyledDialog
onClose={onHide} |
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " <ScopedCssBaseline>\n <StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>\n {list}\n </StyledDrawer>\n </ScopedCssBaseline>\n </div>\n );\n}",
"score": 9.28232764370091
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " <Divider />\n </List>\n )}\n </div>\n );\n })}\n </ListWrapper>\n );\n return (\n <div>",
"score": 8.21283586027409
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " <div\n style={{\n position: 'absolute',\n left: '45%',\n top: '50%'\n }}\n >\n <Button\n sx={{ bottom: '18px' }}\n onClick={() => setDialogVisibility(!dialogVisibility)}",
"score": 7.610155144768684
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " >\n {drawerVisibility ? 'Close SideMenu' : 'Open SideMenu'}\n </Button>\n </div>\n <SideMenu\n visibility={drawerVisibility}\n setVisibility={setDrawerVisibility}\n links={args.links}\n top={args.top}\n />",
"score": 7.10436167779911
},
{
"filename": "src/lib-components/ImageInput/index.tsx",
"retrieved_chunk": " }\n };\n }\n return (\n <div>\n <StyledFieldset\n onMouseEnter={() => setShowImageInput(true)}\n onMouseLeave={() => setShowImageInput(false)}\n >\n <StyledImage",
"score": 6.333297379379703
}
] | typescript | StyledDialog
onClose={onHide} |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
| <StyledImage
src={imageSource ? imageSource : blankAvatar} |
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)}
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nexport const StyledImage = styled.img`\n height: 100%;\n width: 100%;\n border-radius: 15px;\n align-self: center;\n`;\nexport const StyledFieldset = styled.fieldset`\n margin: 0;\n padding: 0;",
"score": 9.692589165511778
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " title: 'Cinnamon',\n h1: true,\n isLandingPage: false,\n haveSearchBar: true,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n footerTitle: 'FOOTER TITLE',",
"score": 6.854793999694932
},
{
"filename": "src/utils/authUtils.ts",
"retrieved_chunk": " const { realm_access } = jwtDecode(auth.user.access_token);\n for (const role of roles) {\n if (realm_access.roles?.includes(role) || role === '*') {\n return true;\n }\n }\n }\n return false;\n}\nexport interface KeycloakPayload {",
"score": 6.751076209458408
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 6.707568559392787
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " }}\n >\n <img\n src={itemBulletIcon}\n alt={`${child.title} Icon`}\n />\n </div>\n <div\n style={{\n display: 'flex',",
"score": 6.391949156254585
}
] | typescript | <StyledImage
src={imageSource ? imageSource : blankAvatar} |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
| src={imageSource ? imageSource : blankAvatar} |
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)}
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nexport const StyledImage = styled.img`\n height: 100%;\n width: 100%;\n border-radius: 15px;\n align-self: center;\n`;\nexport const StyledFieldset = styled.fieldset`\n margin: 0;\n padding: 0;",
"score": 9.692589165511778
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " title: 'Cinnamon',\n h1: true,\n isLandingPage: false,\n haveSearchBar: true,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n footerTitle: 'FOOTER TITLE',",
"score": 6.854793999694932
},
{
"filename": "src/utils/authUtils.ts",
"retrieved_chunk": " const { realm_access } = jwtDecode(auth.user.access_token);\n for (const role of roles) {\n if (realm_access.roles?.includes(role) || role === '*') {\n return true;\n }\n }\n }\n return false;\n}\nexport interface KeycloakPayload {",
"score": 6.751076209458408
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 6.707568559392787
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " }}\n >\n <img\n src={itemBulletIcon}\n alt={`${child.title} Icon`}\n />\n </div>\n <div\n style={{\n display: 'flex',",
"score": 6.391949156254585
}
] | typescript | src={imageSource ? imageSource : blankAvatar} |
import { createContext, useEffect, useMemo, useRef, useState } from 'react';
import { MainDiv } from './styles';
import { Navbar, NavbarProps } from '../Navbar/index';
import { Footer, FooterProps } from '../Footer/index';
import { NavbarContextValue } from './useNavbar';
import { ToastContainer } from '../../components/Toast';
export interface PageProps {
navbar?: NavbarProps;
footer?: FooterProps;
children: JSX.Element | JSX.Element[];
centralized?: boolean;
flexDirection?: 'column' | 'column-reverse' | 'row';
haveToast?: boolean;
components?: {
navbar?: JSX.Element;
footer?: JSX.Element;
toastContainer?: JSX.Element;
};
createNavbarContext: boolean;
}
interface Dimensions {
navHeight: number;
footHeight: number;
}
export const NavbarContext = createContext<NavbarContextValue | undefined>(
undefined
);
export function Page({
navbar,
footer,
children,
centralized = false,
flexDirection,
haveToast = false,
components,
createNavbarContext = true
}: PageProps) {
const navbarRef = useRef<HTMLDivElement>(null);
const footerRef = useRef<HTMLDivElement>(null);
const [dimensions, setDimensions] = useState<Dimensions>({
navHeight: 0,
footHeight: 0
});
const firstRender = useRef<boolean>(true);
useEffect(() => {
setDimensions({
navHeight: navbarRef.current ? navbarRef.current.offsetHeight : 0,
footHeight: footerRef.current ? footerRef.current.offsetHeight : 0
});
}, [navbarRef.current?.offsetHeight, footerRef.current?.offsetHeight]);
let diff = navbar ? dimensions.navHeight : 0;
diff += footer ? dimensions.footHeight : 0;
const [navbarProps, setNavbarProps] = useState<NavbarProps>({
...navbar
});
useEffect(() => {
if (createNavbarContext && !firstRender.current) {
setNavbarProps({ ...navbar });
} else {
firstRender.current = false;
}
}, [navbar]);
const navbarContextClass = useMemo(() => {
if (createNavbarContext) {
return new NavbarContextValue({ ...navbarProps }, setNavbarProps);
}
return undefined;
}, [createNavbarContext, navbarProps, setNavbarProps]);
useEffect(() => {
firstRender.current = true;
}, [navbarContextClass]);
return (
<NavbarContext.Provider value={navbarContextClass}>
<div ref={navbarRef} style={{ display: 'inline' }}>
{components?.navbar ? components.navbar : <Navbar {...navbar} />}
</div>
<div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
<MainDiv
style={{
minHeight: `calc(100vh - ${diff}px)`,
alignItems: centralized ? 'center' : 'normal',
justifyContent: centralized ? 'center' : 'normal',
flexDirection: flexDirection ?? 'column',
flexGrow: 1
}}
>
{haveToast &&
(components?.toastContainer ? (
components.toastContainer
) : (
<ToastContainer
toastProps={{
position: 'top-right'
}}
topInitialPosition={dimensions.navHeight}
/>
))}
{children}
</MainDiv>
</div>
<div ref={footerRef} style={{ display: 'inline' }}>
{components?.footer | ? components.footer : <Footer {...footer} />} |
</div>
</NavbarContext.Provider>
);
}
| src/lib-components/Page/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " return (\n <RequireAuth auth={auth} permittedRoles={permittedRoles}>\n <Page\n navbar={navbar}\n footer={footer}\n centralized={centralized}\n haveToast={haveToast}\n components={components}\n createNavbarContext={createNavbarContext}\n >",
"score": 21.830632556026814
},
{
"filename": "src/lib-components/PageWithAuth/index.tsx",
"retrieved_chunk": " authProps,\n navbar,\n footer,\n centralized = false,\n haveToast = false,\n createNavbarContext = true,\n components,\n children\n}: PageWithAuthProps) {\n const { auth, permittedRoles } = authProps;",
"score": 19.503699689383218
},
{
"filename": "src/lib-components/Page/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nexport const MainDiv = styled.main`\n display: flex;\n padding: 20px clamp(10px, 2%, 40px);\n z-index: 1000;\n background-color: #ffffff;\n`;\nexport const Parent = styled.div`\n display: inline;\n`;",
"score": 16.871753844478786
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " },\n footerLargeFooter: {\n name: 'large footer',\n type: { name: 'boolean', required: false },\n description: 'Boolean which defines if the footer is large or tiny',\n options: [true, false],\n control: { type: 'boolean' },\n table: {\n category: 'Footer'\n }",
"score": 15.173295642597623
},
{
"filename": "src/stories/utils/argTypes.ts",
"retrieved_chunk": " description: \"String wich defines footer's link\",\n control: { type: 'text' },\n table: {\n category: 'Footer'\n }\n },\n footerTextLink: {\n name: 'text link',\n type: { name: 'string', required: false },\n description: \"String wich defines footer's text link\",",
"score": 14.963224375979209
}
] | typescript | ? components.footer : <Footer {...footer} />} |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
<StyledFieldset
onMouseEnter={() => setShowImageInput(true)}
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
src={imageSource ? imageSource : blankAvatar}
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
| <StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </>\n ) : (\n <>\n <StyledAccordion\n disabled\n key={`positions_${position.id}`}\n >\n <AccordionSummary\n expandIcon={<ExpandMoreIcon />}\n aria-controls='panel3a-content'",
"score": 23.71266312049615
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " {\n id: 1,\n name: 'Position 1',\n roles: [\n {\n id: 1,\n name: 'Role 1',\n description: 'Role 1'\n },\n {",
"score": 13.388435494879765
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " id: 2,\n name: 'Role 2',\n description: 'Role 2'\n }\n ]\n },\n {\n id: 2,\n name: 'Position 2',\n roles: [",
"score": 13.388435494879765
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " {\n id: 1,\n name: 'Role 1',\n description: 'Role 1'\n },\n {\n id: 2,\n name: 'Role 2',\n description: 'Role 2'\n }",
"score": 12.961854959456742
},
{
"filename": "src/lib-components/ImageInput/styles.ts",
"retrieved_chunk": " display: flex;\n align-items: center;\n justify-content: center;\n cursor: pointer;\n`;\nexport const StyledSpan = styled.span`\n color: #ffffff;\n font-size: 1.5rem;\n text-align: center;\n`;",
"score": 12.252358104742328
}
] | typescript | <StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
import { SideMenuLink, System, User } from '@/interfaces';
import { useContext } from 'react';
import { NavbarContext } from '.';
import { NavbarProps } from '../Navbar';
import { AuthContextProps } from 'react-oidc-context';
export class NavbarContextValue implements NavbarProps {
auth?: AuthContextProps;
logoRedirectUrl?: string;
logoSrc?: string;
haveSearchBar?: boolean;
hiddenUser?: boolean;
title?: string;
h1?: boolean;
searchFunction?: (searchString: string) => void;
searchDropdownLabelsList?: string[];
logoutFunction?: () => void;
user?: User;
sideMenuLinks?: SideMenuLink[];
isLandingPage?: boolean;
systemsList?: System[];
currentSystemIconUrl?: string;
children?: JSX.Element;
accountManagementUrl?: string;
setNavbarProps: React.Dispatch<React.SetStateAction<NavbarProps>>;
constructor(
navbarProps: NavbarProps,
setNavbarProps: React.Dispatch<React.SetStateAction<NavbarProps>>
) {
this.auth = navbarProps.auth;
this.logoRedirectUrl = navbarProps.logoRedirectUrl;
this.logoSrc = navbarProps.logoSrc;
this.haveSearchBar = navbarProps.haveSearchBar;
this.hiddenUser = navbarProps.hiddenUser;
this.title = navbarProps.title;
this.h1 = navbarProps.h1;
this.searchFunction = navbarProps.searchFunction;
this.searchDropdownLabelsList = navbarProps.searchDropdownLabelsList;
this.logoutFunction = navbarProps.logoutFunction;
this.user = navbarProps.user;
this.sideMenuLinks = navbarProps.sideMenuLinks;
this.isLandingPage = navbarProps.isLandingPage;
this.systemsList = navbarProps.systemsList;
this.currentSystemIconUrl = navbarProps.currentSystemIconUrl;
| this.children = navbarProps.children; |
this.accountManagementUrl = navbarProps.accountManagementUrl;
this.setNavbarProps = setNavbarProps;
}
setTitle(newTitle: string) {
if (newTitle !== this.title) {
this.title = newTitle;
this.setNavbarProps({ ...this });
}
}
setSearchFuncion(newSearchFunction: (searchString: string) => void) {
if (newSearchFunction !== this.searchFunction) {
this.searchFunction = newSearchFunction;
this.setNavbarProps({ ...this });
}
}
setHaveSearchBar(newHaveSearchBar: boolean) {
if (newHaveSearchBar !== this.haveSearchBar) {
this.haveSearchBar = newHaveSearchBar;
this.setNavbarProps({ ...this });
}
}
setSideMenuLinks(newSideMenuLinks: SideMenuLink[]) {
if (newSideMenuLinks !== this.sideMenuLinks) {
this.sideMenuLinks = newSideMenuLinks;
this.setNavbarProps({ ...this });
}
}
}
export const useNavbar = (): NavbarContextValue | undefined => {
const contextValue: NavbarContextValue | undefined =
useContext(NavbarContext);
if (!contextValue) {
throw new Error('Navbar context not available.');
}
return contextValue;
};
| src/lib-components/Page/useNavbar.ts | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }\n }, [navbar]);\n const navbarContextClass = useMemo(() => {\n if (createNavbarContext) {\n return new NavbarContextValue({ ...navbarProps }, setNavbarProps);\n }\n return undefined;\n }, [createNavbarContext, navbarProps, setNavbarProps]);\n useEffect(() => {\n firstRender.current = true;",
"score": 73.65820409959929
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " title = '',\n h1 = false,\n sideMenuLinks = [],\n isLandingPage = false,\n systemsList = [],\n currentSystemIconUrl,\n children,\n IconComponent,\n accountManagementUrl\n}: NavbarProps) => {",
"score": 51.367332945213406
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " let diff = navbar ? dimensions.navHeight : 0;\n diff += footer ? dimensions.footHeight : 0;\n const [navbarProps, setNavbarProps] = useState<NavbarProps>({\n ...navbar\n });\n useEffect(() => {\n if (createNavbarContext && !firstRender.current) {\n setNavbarProps({ ...navbar });\n } else {\n firstRender.current = false;",
"score": 44.59165758776785
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " user?: User;\n sideMenuLinks?: SideMenuLink[];\n isLandingPage?: boolean;\n systemsList?: System[];\n currentSystemIconUrl?: string;\n IconComponent?: JSXElementConstructor<any>;\n children?: JSX.Element;\n accountManagementUrl?: string;\n}\nexport const Navbar = ({",
"score": 39.65119399238327
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " user: args.hiddenUser ? undefined : args.user,\n h1: args.h1,\n children: undefined,\n title: args.title,\n sideMenuLinks: args.sideMenuLinks,\n systemsList: args.systemsList ? args.systemsList : undefined,\n IconComponent\n }}\n footer={{\n title: args.footerTitle,",
"score": 37.688650142911854
}
] | typescript | this.children = navbarProps.children; |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
this.qb = qb.set(parameterizedValues) as QB;
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.instantiateNoReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
| : result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
); |
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
| src/queries/compiling-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " await this.run(obj);\n return;\n }\n const transformedObj = this.applyInsertTransform(obj);\n const compiledQuery = this.instantiateWithReturns({}, transformedObj);\n const result = await this.db.executeQuery(compiledQuery);\n if (result.rows.length === 0) {\n throw Error(\n 'No row returned from compiled insert expecting returned columns'\n );",
"score": 92.24297351422075
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ? (returns as any)\n : returns.map((row) =>\n this.transforms.updateReturnTransform!(\n obj as UpdatingObject,\n row as any\n )\n );\n }\n /**\n * Updates rows with the values that result from transforming the object via",
"score": 76.39832865905609
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " }\n const result = await this.loadInsertedObjects(\n this.getReturningQB(),\n obj\n ).executeTakeFirst();\n return this.transforms.insertReturnTransform === undefined\n ? (result as any)\n : this.transforms.insertReturnTransform(obj, result as any);\n }\n /**",
"score": 75.14157327406954
},
{
"filename": "src/queries/compiling-select-query.ts",
"retrieved_chunk": " if (!result) return null;\n return result === undefined\n ? null\n : this.transforms.selectTransform === undefined\n ? (result as SelectedObject)\n : this.transforms.selectTransform(result as any);\n }\n}",
"score": 64.69840829510761
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " const result = await this.loadUpdatingObject(\n this.qb,\n obj\n ).executeTakeFirst();\n return this.transforms.countTransform === undefined\n ? (result.numUpdatedRows as ReturnCount)\n : this.transforms.countTransform(result.numUpdatedRows);\n }\n /**\n * Updates rows with the values that result from transforming the object via",
"score": 62.46951978367412
}
] | typescript | : result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
); |
import { Insertable, Selectable, Selection, Updateable } from 'kysely';
import {
SelectableColumnTuple,
SelectedRow,
SelectionColumn,
} from '../lib/type-utils';
import { TableMapperTransforms } from './table-mapper-transforms';
import { AbstractTableMapper } from './abstract-table-mapper';
/**
* Table mapper that defaults to passing through all query inputs and output
* unchanged, allowing the selective overloading of transforms.
* @typeParam DB Interface whose fields are table names defining tables.
* @typeParam TB Name of the table.
* @typeParam KeyColumns Tuple of the names of the table's key columns.
* Defaults to `[]`, indicating no key columns. Supports up to 4 columns.
* @typeParam SelectedColumns Columns to return from selection queries.
* Defaults to `['*']`, returning all columns. May specify aliases.
* @typeParam SelectedObject Type of objects returned by select queries.
* @typeParam InsertedObject Type of objects inserted into the table.
* @typeParam UpdatingObject Type of objects used to update rows of the table.
* @typeParam Type of the count of the number of affected rows.
* @typeParam InsertReturnColumns Columns to return from the table on insert
* queries that return columns. `['*']` returns all columns; `[]` returns
* none. May specify aliases. Defaults to `KeyColumns`.
* @typeParam UpdateReturnColumns Columns to return from the table on update
* queries that return columns. `['*']` returns all columns; `[]` returns
* none and is the default. May specify aliases.
* @typeParam InsertReturn Type returned from inserts. Defaults to an object
* whose properties are the columns of `InsertReturnColumns`.
* @typeParam UpdateReturn Type returned from updates. Defaults to an object
* whose properties are the columns of `UpdateReturnColumns`.
*/
export class TableMapper<
DB,
TB extends keyof DB & string,
KeyColumns extends
| Readonly<SelectableColumnTuple<DB[TB]>>
| Readonly<[]> = [],
SelectedColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'] = ['*'],
SelectedObject = SelectedRow<
DB,
TB,
SelectedColumns extends ['*'] ? never : SelectedColumns[number],
SelectedColumns
>,
InsertedObject = Insertable<DB[TB]>,
UpdatingObject = Updateable<DB[TB]>,
ReturnCount = bigint,
InsertReturnColumns extends
| Readonly<SelectionColumn<DB, TB>[]>
| ['*'] = Readonly<KeyColumns>,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'] = [],
InsertReturn = InsertReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, InsertReturnColumns[number]>,
UpdateReturn = UpdateReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, UpdateReturnColumns[number]>
> extends AbstractTableMapper<
DB,
TB,
KeyColumns,
SelectedColumns,
SelectedObject,
InsertedObject,
UpdatingObject,
ReturnCount,
InsertReturnColumns,
UpdateReturnColumns,
InsertReturn,
UpdateReturn
> {
/**
* Returns a new table mapper that uses the provided transformations, along
* with the settings of the current table mapper.
* @param transforms The transforms to use.
* @returns A new table mapper that uses the provided transforms.
*/
withTransforms<
SelectedObject = SelectedRow<
DB,
TB,
SelectedColumns extends ['*'] ? never : SelectedColumns[number],
SelectedColumns
>,
InsertedObject = Insertable<DB[TB]>,
UpdatingObject = Updateable<DB[TB]>,
ReturnCount = bigint,
InsertReturn = InsertReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, InsertReturnColumns[number]>,
UpdateReturn = UpdateReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, UpdateReturnColumns[number]>
>(
transforms: Readonly<
TableMapperTransforms<
DB,
TB,
KeyColumns,
SelectedColumns,
SelectedObject,
InsertedObject,
UpdatingObject,
ReturnCount,
InsertReturnColumns,
UpdateReturnColumns,
InsertReturn,
UpdateReturn
>
>
) {
const transformingTableMapper = new TableMapper<
DB,
TB,
KeyColumns,
SelectedColumns,
SelectedObject,
InsertedObject,
UpdatingObject,
ReturnCount,
InsertReturnColumns,
UpdateReturnColumns,
InsertReturn,
UpdateReturn
>(this.db, this.tableName, this.settings);
| transformingTableMapper.transforms = transforms; |
return transformingTableMapper;
}
}
| src/mappers/table-mapper.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn,\n this,\n Parameters,",
"score": 38.91294489943072
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn\n > = {};",
"score": 31.730968656126823
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " KeyColumns,\n SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn,",
"score": 31.14141169211724
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " KeyColumns,\n SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn,",
"score": 31.14141169211724
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " NextQB,\n UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new MappingUpdateQuery(\n this.db,\n factory(this.qb),\n this.transforms,",
"score": 30.540640603369997
}
] | typescript | transformingTableMapper.transforms = transforms; |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingUpdateQuery } from './update-query';
import { SubsettingMappingUpdateQuery } from './subsetting-update-query';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Mapping query for updating rows from a database table, where the
* columns to be updated have not been restricted.
*/
export class AnyColumnsMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn
> extends MappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
> {
constructor(
db: Kysely<DB>,
qb: QB,
transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a mapping query that only updates a specified subset of columns.
* @param columns The columns to update. All are required, but this
* constraint is only enforced at runtime, not by the type system.
* @returns A mapping query that only updates the specified columns.
*/
columns(
columnsToUpdate: Readonly<(keyof Updateable<DB[TB]> & string)[]>
): SubsettingMappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
> {
return new SubsettingMappingUpdateQuery(
this.db,
this | .qb,
columnsToUpdate,
this.transforms,
this.returnColumns
); |
}
}
| src/queries/any-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn,\n Parameters\n > {\n return new CompilingMappingUpdateQuery(\n this.db,\n this.qb,\n this.columnsToUpdate,",
"score": 31.67892937213859
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns,\n UpdateReturn\n >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, returnColumns);\n const parameterizedValues = this.getParameterizedObject(columnsToUpdate);\n this.qb = qb.set(parameterizedValues) as QB;\n }",
"score": 30.37881415456848
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " > {\n return new CompilingMappingInsertQuery(\n this.db,\n this.qb,\n this.columnsToInsert,\n this.transforms,\n this.returnColumns\n );\n }\n protected override getInsertColumns():",
"score": 29.19231687405037
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " NextQB,\n UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new MappingUpdateQuery(\n this.db,\n factory(this.qb),\n this.transforms,",
"score": 27.801513709719966
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " this.transforms,\n this.returnColumns\n );\n }\n protected override getUpdateColumns():\n | Readonly<(keyof Updateable<DB[TB]> & string)[]>\n | ['*'] {\n return this.columnsToUpdate;\n }\n protected override setColumnValues(",
"score": 26.257569573155806
}
] | typescript | .qb,
columnsToUpdate,
this.transforms,
this.returnColumns
); |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingUpdateQuery } from './update-query';
import { ParameterizableMappingQuery } from './parameterizable-query';
import { ParametersObject } from 'kysely-params';
import { CompilingMappingUpdateQuery } from './compiling-update-query';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
import { restrictValues } from '../lib/restrict-values';
/**
* Mapping query for updating rows into a database table,
* updating a specified subset of the updateable columns.
*/
export class SubsettingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn
>
extends MappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
>
implements ParameterizableMappingQuery
{
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a compiling query that can be executed multiple times with
* different parameters (if any parameters were provided), but which only
* compiles the underlying Kysely query builder on the first execution.
* Frees the query builder on the first execution to reduce memory usage.
* @typeParam Parameters Record characterizing the parameter names and
* types that were previously embedded in the query, if any.
* @returns A compiling update query.
*/
compile<
Parameters extends ParametersObject<Parameters> = {}
>(): CompilingMappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn,
Parameters
> {
return new CompilingMappingUpdateQuery(
this.db,
this.qb,
this.columnsToUpdate,
this.transforms,
this.returnColumns
);
}
protected override getUpdateColumns():
| Readonly<(keyof Updateable<DB[TB]> & string)[]>
| ['*'] {
return this.columnsToUpdate;
}
protected override setColumnValues(
qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
obj: Updateable<DB[TB]>
): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {
| return qb.set(restrictValues(obj, this.columnsToUpdate)); |
}
}
| src/queries/subsetting-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " * @param qb The query builder to set the values into.\n * @param obj The object of column-value pairs to be updated.\n */\n protected setColumnValues(\n qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n obj: Updateable<DB[TB]>\n ): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {\n return qb.set(obj);\n }\n}",
"score": 78.6021597084765
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {\n const updateColumns = this.getUpdateColumns();\n const transformedObj =\n this.transforms.updateTransform === undefined\n ? (obj as Updateable<DB[TB]>)\n : this.transforms.updateTransform(obj, updateColumns);\n return this.setColumnValues(qb, transformedObj);\n }\n /**\n * Sets the values of the updated columns.",
"score": 67.80091729109964
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " | Readonly<(keyof Insertable<DB[TB]> & string)[]>\n | ['*'] {\n return this.columnsToInsert;\n }\n protected override setColumnValues(\n qb: InsertQueryBuilder<DB, TB, InsertResult>,\n objOrObjs: Insertable<DB[TB]> | Insertable<DB[TB]>[]\n ): InsertQueryBuilder<DB, TB, InsertResult> {\n if (Array.isArray(objOrObjs)) {\n return qb.values(",
"score": 62.27107455027974
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " qb: QB,\n protected readonly columnsToUpdate: Readonly<\n (keyof Updateable<DB[TB]> & string)[]\n >,\n protected readonly transforms: Readonly<\n CountTransform<ReturnCount> &\n UpdateTransforms<\n DB,\n TB,\n UpdatingObject,",
"score": 61.779316977071005
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " */\n async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {\n return (await this.returnCount(params, obj)) !== 0;\n }\n protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {\n return this.transforms.updateTransform === undefined\n ? (obj as Updateable<DB[TB]>)\n : this.transforms.updateTransform(obj, this.columnsToUpdate);\n }\n protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {",
"score": 58.070308216312895
}
] | typescript | return qb.set(restrictValues(obj, this.columnsToUpdate)); |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
| const parameterizedValues = this.getParameterizedObject(columnsToUpdate); |
this.qb = qb.set(parameterizedValues) as QB;
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.instantiateNoReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
| src/queries/compiling-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " UpdateTransforms<\n DB,\n TB,\n UpdatingObject,\n UpdateReturnColumns,\n UpdateReturn\n >\n >,\n protected readonly returnColumns: Readonly<UpdateReturnColumns>\n ) {}",
"score": 29.46460854599882
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn,\n Parameters\n > {\n return new CompilingMappingUpdateQuery(\n this.db,\n this.qb,\n this.columnsToUpdate,",
"score": 25.145695199366624
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " DB,\n TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, returnColumns);",
"score": 24.47542858298906
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }",
"score": 24.10799232840159
},
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n > {\n return new SubsettingMappingUpdateQuery(\n this.db,\n this.qb,\n columnsToUpdate,\n this.transforms,\n this.returnColumns\n );",
"score": 23.815512395312545
}
] | typescript | const parameterizedValues = this.getParameterizedObject(columnsToUpdate); |
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = | this.getParameterizedObject(columnsToInsert); |
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
| src/queries/compiling-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns,\n UpdateReturn\n >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, returnColumns);\n const parameterizedValues = this.getParameterizedObject(columnsToUpdate);\n this.qb = qb.set(parameterizedValues) as QB;\n }",
"score": 40.13517220543895
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }",
"score": 38.63704422558686
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new SubsettingMappingInsertQuery(\n this.db,\n this.qb,\n columnsToInsert,",
"score": 25.996120178034005
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * @returns If `returnColumns` is not empty, returns an object;\n * otherwise returns `undefined`.\n */\n returnOne(\n obj: InsertedObject\n ): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;\n async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {\n if (this.returnColumns.length === 0) {\n await this.loadInsertedObjects(this.qb, obj).execute();\n return;",
"score": 23.133140168565216
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n> {\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToInsert: Readonly<\n (keyof Insertable<DB[TB]> & string)[]",
"score": 23.098620742770144
}
] | typescript | this.getParameterizedObject(columnsToInsert); |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
this.qb = qb.set(parameterizedValues) as QB;
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery | = this.instantiateNoReturns(params, transformedObj); |
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
| src/queries/compiling-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " this.returnColumns\n );\n }\n /**\n * Runs the query, returning the number of rows updated, in\n * the required client representation.\n * @param obj The object which which to update the rows.\n * @returns Number of rows updated, in client-requested representation.\n */\n async returnCount(obj: UpdatingObject): Promise<ReturnCount> {",
"score": 89.1177024215704
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " /**\n * Runs the query, updating rows, without returning any columns.\n * @param obj The object which which to update the rows.\n * @returns `true` if any rows were updated, `false` otherwise.\n */\n async run(obj: UpdatingObject): Promise<boolean> {\n const results = await this.loadUpdatingObject(\n this.qb,\n obj\n ).executeTakeFirst();",
"score": 58.33928440458851
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " * query builder. Subsequent executions reuse the compiled query.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(obj: InsertedObject): Promise<boolean> {\n const transformedObj = this.applyInsertTransform(obj);\n const compiledQuery = this.instantiateNoReturns({}, transformedObj);\n await this.db.executeQuery(compiledQuery);\n return true;\n }",
"score": 55.488884117786114
},
{
"filename": "src/queries/compiling-delete-query.ts",
"retrieved_chunk": " * @param params Record characterizing the parameter names and types.\n * Pass in `{}` if the query has no parameters.\n * @returns Number of rows deleted, in client-requested representation.\n */\n async returnCount(params: Parameters): Promise<ReturnCount> {\n const result = await this.#parameterizedQuery.execute(this.db, params);\n return this.transforms.countTransform === undefined\n ? (result.numAffectedRows! as ReturnCount)\n : this.transforms.countTransform(result.numAffectedRows!);\n }",
"score": 55.32535893650774
},
{
"filename": "src/queries/delete-query.ts",
"retrieved_chunk": " Parameters extends ParametersObject<Parameters> = {}\n >(): CompilingMappingDeleteQuery<DB, TB, QB, ReturnCount, Parameters> {\n return new CompilingMappingDeleteQuery(this.db, this.qb, this.transforms);\n }\n /**\n * Runs the query, returning the number of rows deleted, converted to\n * the required client representation.\n * @returns Number of rows deleted, in client-requested representation.\n */\n async returnCount(): Promise<ReturnCount> {",
"score": 54.268391530179734
}
] | typescript | = this.instantiateNoReturns(params, transformedObj); |
import { Kysely, InsertQueryBuilder, InsertResult, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { SubsettingMappingInsertQuery } from './subsetting-insert-query';
import { MappingInsertQuery } from './insert-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Mapping query for inserting rows into a database table, where the
* columns to be inserted have not been restricted.
*/
export class AnyColumnsMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, InsertResult>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends MappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
constructor(
db: Kysely<DB>,
qb: QB,
transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a mapping query that only inserts a specified subset of columns.
* @param columns The columns to insert. All are required, but this
* constraint is only enforced at runtime, not by the type system.
* @returns A mapping query that only inserts the specified columns.
*/
columns(
columnsToInsert: Readonly<(keyof Insertable<DB[TB]> & string)[]>
): SubsettingMappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
return new SubsettingMappingInsertQuery(
this.db,
this. | qb,
columnsToInsert,
this.transforms,
this.returnColumns
); |
}
}
| src/queries/any-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " > {\n return new CompilingMappingInsertQuery(\n this.db,\n this.qb,\n this.columnsToInsert,\n this.transforms,\n this.returnColumns\n );\n }\n protected override getInsertColumns():",
"score": 35.180384664531665
},
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n > {\n return new SubsettingMappingUpdateQuery(\n this.db,\n this.qb,\n columnsToUpdate,\n this.transforms,\n this.returnColumns\n );",
"score": 29.43553008408217
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new AnyColumnsMappingInsertQuery(\n this.db,\n this.getInsertQB(),\n this.transforms,\n this.insertReturnColumns as InsertReturnColumns\n );",
"score": 25.991553459186626
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " objOrObjs.map((obj) => restrictValues(obj, this.columnsToInsert))\n );\n }\n return qb.values(restrictValues(objOrObjs, this.columnsToInsert));\n }\n}",
"score": 24.731033780516928
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " NextQB,\n UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new MappingUpdateQuery(\n this.db,\n factory(this.qb),\n this.transforms,",
"score": 24.392709150933666
}
] | typescript | qb,
columnsToInsert,
this.transforms,
this.returnColumns
); |
import { Kysely, InsertQueryBuilder, InsertResult, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingInsertQuery } from './insert-query';
import { CompilingMappingInsertQuery } from './compiling-insert-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
import { restrictValues } from '../lib/restrict-values';
/**
* Mapping query for inserting rows into a database table,
* inserting a specified subset of the insertable columns.
*/
export class SubsettingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, InsertResult>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends MappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a compiling query that can be executed multiple times with
* different parameters (if any parameters were provided), but which only
* compiles the underlying Kysely query builder on the first execution.
* Frees the query builder on the first execution to reduce memory usage.
* @typeParam Parameters Record characterizing the parameter names and
* types that were previously embedded in the query, if any.
* @returns A compiling insert query.
*/
compile(): CompilingMappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
return new CompilingMappingInsertQuery(
this.db,
this.qb,
this.columnsToInsert,
this.transforms,
this.returnColumns
);
}
protected override getInsertColumns():
| Readonly<(keyof Insertable<DB[TB]> & string)[]>
| ['*'] {
return this.columnsToInsert;
}
protected override setColumnValues(
qb: InsertQueryBuilder<DB, TB, InsertResult>,
objOrObjs: Insertable<DB[TB]> | Insertable<DB[TB]>[]
): InsertQueryBuilder<DB, TB, InsertResult> {
if (Array.isArray(objOrObjs)) {
return qb.values(
| objOrObjs.map((obj) => restrictValues(obj, this.columnsToInsert))
); |
}
return qb.values(restrictValues(objOrObjs, this.columnsToInsert));
}
}
| src/queries/subsetting-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " */\n protected setColumnValues(\n qb: InsertQueryBuilder<DB, TB, InsertResult>,\n objOrObjs: Insertable<DB[TB]> | Insertable<DB[TB]>[]\n ): InsertQueryBuilder<DB, TB, InsertResult> {\n return qb.values(objOrObjs);\n }\n}",
"score": 96.67905992045338
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * @param objOrObjs The object or objects to be inserted.\n * @returns The query builder with the objects loaded.\n */\n protected loadInsertedObjects(\n qb: InsertQueryBuilder<DB, TB, InsertResult>,\n objOrObjs: InsertedObject | InsertedObject[]\n ): InsertQueryBuilder<DB, TB, InsertResult> {\n const insertColumns = this.getInsertColumns();\n if (Array.isArray(objOrObjs)) {\n const transformedObjs =",
"score": 77.50477502829591
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " this.transforms.insertTransform === undefined\n ? (objOrObjs as Insertable<DB[TB]>[])\n : objOrObjs.map((obj) =>\n this.transforms.insertTransform!(obj, insertColumns)\n );\n // TS requires separate calls to values() for different arg types.\n return this.setColumnValues(qb, transformedObjs);\n }\n const transformedObj =\n this.transforms.insertTransform === undefined",
"score": 64.22826582894463
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {\n return this.transforms.insertTransform === undefined\n ? (obj as Insertable<DB[TB]>)\n : this.transforms.insertTransform(obj, this.columnsToInsert);\n }\n}",
"score": 57.51379827550653
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " ? (objOrObjs as Insertable<DB[TB]>)\n : this.transforms.insertTransform(objOrObjs, insertColumns);\n // TS requires separate calls to values() for different arg types.\n return this.setColumnValues(qb, transformedObj);\n }\n /**\n * Sets the values of the inserted columns.\n * @param qb The query builder to set the values into.\n * @param objOrObjs The object or objects of column-value pairs\n * to be inserted.",
"score": 51.028981341232424
}
] | typescript | objOrObjs.map((obj) => restrictValues(obj, this.columnsToInsert))
); |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingUpdateQuery } from './update-query';
import { ParameterizableMappingQuery } from './parameterizable-query';
import { ParametersObject } from 'kysely-params';
import { CompilingMappingUpdateQuery } from './compiling-update-query';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
import { restrictValues } from '../lib/restrict-values';
/**
* Mapping query for updating rows into a database table,
* updating a specified subset of the updateable columns.
*/
export class SubsettingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn
>
extends MappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
>
implements ParameterizableMappingQuery
{
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a compiling query that can be executed multiple times with
* different parameters (if any parameters were provided), but which only
* compiles the underlying Kysely query builder on the first execution.
* Frees the query builder on the first execution to reduce memory usage.
* @typeParam Parameters Record characterizing the parameter names and
* types that were previously embedded in the query, if any.
* @returns A compiling update query.
*/
compile<
Parameters extends ParametersObject<Parameters> = {}
>(): CompilingMappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn,
Parameters
> {
return new CompilingMappingUpdateQuery(
this.db,
this.qb,
this.columnsToUpdate,
this.transforms,
this.returnColumns
);
}
protected | override getUpdateColumns():
| Readonly<(keyof Updateable<DB[TB]> & string)[]>
| ['*'] { |
return this.columnsToUpdate;
}
protected override setColumnValues(
qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
obj: Updateable<DB[TB]>
): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {
return qb.set(restrictValues(obj, this.columnsToUpdate));
}
}
| src/queries/subsetting-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " > {\n return new CompilingMappingInsertQuery(\n this.db,\n this.qb,\n this.columnsToInsert,\n this.transforms,\n this.returnColumns\n );\n }\n protected override getInsertColumns():",
"score": 34.063133491409495
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " this.#returningQB =\n this.returnColumns[0 as number] == '*'\n ? this.qb.returningAll()\n : this.qb.returning(\n this.returnColumns as Readonly<\n (keyof Selectable<DB[TB]> & string)[]\n >\n );\n }\n return this.#returningQB;",
"score": 32.91157483571641
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " qb: QB,\n protected readonly columnsToUpdate: Readonly<\n (keyof Updateable<DB[TB]> & string)[]\n >,\n protected readonly transforms: Readonly<\n CountTransform<ReturnCount> &\n UpdateTransforms<\n DB,\n TB,\n UpdatingObject,",
"score": 31.37002042378198
},
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n > {\n return new SubsettingMappingUpdateQuery(\n this.db,\n this.qb,\n columnsToUpdate,\n this.transforms,\n this.returnColumns\n );",
"score": 30.643780021649107
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " */\n async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {\n return (await this.returnCount(params, obj)) !== 0;\n }\n protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {\n return this.transforms.updateTransform === undefined\n ? (obj as Updateable<DB[TB]>)\n : this.transforms.updateTransform(obj, this.columnsToUpdate);\n }\n protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {",
"score": 29.856339949843893
}
] | typescript | override getUpdateColumns():
| Readonly<(keyof Updateable<DB[TB]> & string)[]>
| ['*'] { |
import {
ComparisonOperatorExpression,
Kysely,
OperandValueExpressionOrList,
ReferenceExpression,
WhereInterface,
} from 'kysely';
import { SelectableColumnTuple } from './type-utils';
import { QueryFilter } from './query-filter';
type AnyWhereInterface = WhereInterface<any, any>;
/**
* Returns a query builder that constrains the provided query builder
* according to the provided query filter or binary operation.
* @param base The Kysely mapper that is used to create references.
* @param qb The query builder to constrain.
* @param filterOrLHS The query filter or left-hand side of a binary operation.
* @param op The operator of a binary operation.
* @param rhs The right-hand side of a binary operation.
* @returns A query builder constrained for the provided query filter
* or binary operation.
*/
export function applyQueryFilter<
DB,
TB extends keyof DB & string,
KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,
QB extends AnyWhereInterface,
RE extends ReferenceExpression<DB, TB>
>(
db: Kysely<DB>,
qb: QB,
keyColumns: KeyColumns,
filterOrLHS: QueryFilter<DB, TB, KeyColumns, RE> | RE,
op?: ComparisonOperatorExpression,
rhs?: OperandValueExpressionOrList<DB, TB, RE>
): QB {
// Process a binary operation.
if (op !== undefined) {
return qb.where(filterOrLHS as RE, op, rhs!) as QB;
}
const filter = filterOrLHS as QueryFilter<DB, TB, KeyColumns, RE>;
if (typeof filter === 'object') {
// Process a key tuple filter.
if (Array.isArray(filter)) {
keyColumns.forEach | ((column, i) => { |
qb = qb.where(db.dynamic.ref(column), '=', filter[i]) as QB;
});
return qb;
}
// Process a query expression filter. Check for expressions
// first because they could potentially be plain objects.
if ('expressionType' in filter) {
return qb.where(filter) as QB;
}
// Process a field matching filter. `{}` matches all rows.
if (filter.constructor === Object) {
for (const [column, value] of Object.entries(filter)) {
if (Array.isArray(value)) {
qb = qb.where(db.dynamic.ref(column), 'in', value) as QB;
} else {
qb = qb.where(db.dynamic.ref(column), '=', value) as QB;
}
}
return qb as unknown as QB;
}
}
// Process a where expression factory.
if (typeof filter === 'function') {
return qb.where(filter as any) as QB;
}
// Process a single key filter, expressed as a primitive value.
if (keyColumns.length === 1) {
return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) as QB;
}
throw Error('Unrecognized query filter');
}
| src/lib/apply-query-filter.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " filter?: QueryFilter<DB, TB, KeyColumns, RE>\n ): MappingDeleteQuery<\n DB,\n TB,\n DeleteQueryBuilder<DB, TB, DeleteResult>,\n ReturnCount\n >;\n delete<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,",
"score": 58.31769278533078
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " * the provided filter or Kysely binary operation.\n * @param filter Optional filter to apply to the query or the left-hand-side\n * of a Kysely binary operation.\n * @returns A mapping query for retrieving rows as objects.\n */\n select<RE extends ReferenceExpression<DB, TB>>(\n lhs: RE,\n op: ComparisonOperatorExpression,\n rhs: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 56.997009856901286
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " TB,\n SelectedColumns,\n SelectedObject,\n SelectQueryBuilder<DB, TB, object>\n >;\n select<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,\n rhs?: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 51.47015434640802
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdateReturn\n >;\n update<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,\n rhs?: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,",
"score": 48.750820370991306
},
{
"filename": "src/lib/query-filter.ts",
"retrieved_chunk": " WhereExpressionFactory,\n} from 'kysely';\nimport { KeyTuple, SelectableColumnTuple } from './type-utils';\n/**\n * Type of the query filter object, which can be passed as an argument\n * to query functions to constrain results. A filter can be any of the\n * following:\n *\n * - A key column value, which matches a single key column, if\n * `KeyColumns` is a tuple with a single element.",
"score": 41.196586804438454
}
] | typescript | ((column, i) => { |
import {
ComparisonOperatorExpression,
Kysely,
OperandValueExpressionOrList,
ReferenceExpression,
WhereInterface,
} from 'kysely';
import { SelectableColumnTuple } from './type-utils';
import { QueryFilter } from './query-filter';
type AnyWhereInterface = WhereInterface<any, any>;
/**
* Returns a query builder that constrains the provided query builder
* according to the provided query filter or binary operation.
* @param base The Kysely mapper that is used to create references.
* @param qb The query builder to constrain.
* @param filterOrLHS The query filter or left-hand side of a binary operation.
* @param op The operator of a binary operation.
* @param rhs The right-hand side of a binary operation.
* @returns A query builder constrained for the provided query filter
* or binary operation.
*/
export function applyQueryFilter<
DB,
TB extends keyof DB & string,
KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,
QB extends AnyWhereInterface,
RE extends ReferenceExpression<DB, TB>
>(
db: Kysely<DB>,
qb: QB,
keyColumns: KeyColumns,
filterOrLHS: QueryFilter<DB, TB, KeyColumns, RE> | RE,
op?: ComparisonOperatorExpression,
rhs?: OperandValueExpressionOrList<DB, TB, RE>
): QB {
// Process a binary operation.
if (op !== undefined) {
return qb.where(filterOrLHS as RE, op, rhs!) as QB;
}
const filter = filterOrLHS as QueryFilter<DB, TB, KeyColumns, RE>;
if (typeof filter === 'object') {
// Process a key tuple filter.
if (Array.isArray(filter)) {
| keyColumns.forEach((column, i) => { |
qb = qb.where(db.dynamic.ref(column), '=', filter[i]) as QB;
});
return qb;
}
// Process a query expression filter. Check for expressions
// first because they could potentially be plain objects.
if ('expressionType' in filter) {
return qb.where(filter) as QB;
}
// Process a field matching filter. `{}` matches all rows.
if (filter.constructor === Object) {
for (const [column, value] of Object.entries(filter)) {
if (Array.isArray(value)) {
qb = qb.where(db.dynamic.ref(column), 'in', value) as QB;
} else {
qb = qb.where(db.dynamic.ref(column), '=', value) as QB;
}
}
return qb as unknown as QB;
}
}
// Process a where expression factory.
if (typeof filter === 'function') {
return qb.where(filter as any) as QB;
}
// Process a single key filter, expressed as a primitive value.
if (keyColumns.length === 1) {
return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) as QB;
}
throw Error('Unrecognized query filter');
}
| src/lib/apply-query-filter.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " filter?: QueryFilter<DB, TB, KeyColumns, RE>\n ): MappingDeleteQuery<\n DB,\n TB,\n DeleteQueryBuilder<DB, TB, DeleteResult>,\n ReturnCount\n >;\n delete<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,",
"score": 58.31769278533078
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " * the provided filter or Kysely binary operation.\n * @param filter Optional filter to apply to the query or the left-hand-side\n * of a Kysely binary operation.\n * @returns A mapping query for retrieving rows as objects.\n */\n select<RE extends ReferenceExpression<DB, TB>>(\n lhs: RE,\n op: ComparisonOperatorExpression,\n rhs: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 56.997009856901286
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " TB,\n SelectedColumns,\n SelectedObject,\n SelectQueryBuilder<DB, TB, object>\n >;\n select<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,\n rhs?: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 51.47015434640802
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdateReturn\n >;\n update<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,\n rhs?: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,",
"score": 48.750820370991306
},
{
"filename": "src/lib/query-filter.ts",
"retrieved_chunk": " WhereExpressionFactory,\n} from 'kysely';\nimport { KeyTuple, SelectableColumnTuple } from './type-utils';\n/**\n * Type of the query filter object, which can be passed as an argument\n * to query functions to constrain results. A filter can be any of the\n * following:\n *\n * - A key column value, which matches a single key column, if\n * `KeyColumns` is a tuple with a single element.",
"score": 41.196586804438454
}
] | typescript | keyColumns.forEach((column, i) => { |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
this.qb = qb.set(parameterizedValues) as QB;
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.instantiateNoReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
| const compiledQuery = this.instantiateWithReturns(params, transformedObj); |
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
| src/queries/compiling-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(obj: UpdatingObject): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();",
"score": 68.83560536951974
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " async returnAll(obj: UpdatingObject): Promise<UpdateReturn[] | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();\n return this.transforms.updateReturnTransform === undefined",
"score": 68.10426833465485
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " await this.run(obj);\n return;\n }\n const transformedObj = this.applyInsertTransform(obj);\n const compiledQuery = this.instantiateWithReturns({}, transformedObj);\n const result = await this.db.executeQuery(compiledQuery);\n if (result.rows.length === 0) {\n throw Error(\n 'No row returned from compiled insert expecting returned columns'\n );",
"score": 59.94364671229372
},
{
"filename": "src/queries/compiling-values-query.ts",
"retrieved_chunk": " protected instantiateNoReturns(\n params: Parameters,\n obj: Values\n ): CompiledQuery<any> {\n this.compileQueries();\n return this.instantiate(this.#compiledQueryNoReturns!, params, obj);\n }\n protected instantiateWithReturns(\n params: Parameters,\n obj: Values",
"score": 59.59783056728824
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " * query builder. Subsequent executions reuse the compiled query.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(obj: InsertedObject): Promise<boolean> {\n const transformedObj = this.applyInsertTransform(obj);\n const compiledQuery = this.instantiateNoReturns({}, transformedObj);\n await this.db.executeQuery(compiledQuery);\n return true;\n }",
"score": 48.07168474459336
}
] | typescript | const compiledQuery = this.instantiateWithReturns(params, transformedObj); |
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this | .instantiateWithReturns({}, transformedObj); |
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
| src/queries/compiling-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * @returns If `returnColumns` is not empty, returns an object;\n * otherwise returns `undefined`.\n */\n returnOne(\n obj: InsertedObject\n ): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;\n async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {\n if (this.returnColumns.length === 0) {\n await this.loadInsertedObjects(this.qb, obj).execute();\n return;",
"score": 81.1287498339723
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " obj: UpdatingObject\n ): Promise<UpdateReturn[] | void> {\n if (this.returnColumns.length === 0) {\n await this.run(params, obj as UpdatingObject);\n return;\n }\n const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);\n const compiledQuery = this.instantiateWithReturns(params, transformedObj);\n const result = await this.db.executeQuery(compiledQuery);\n return this.transforms.updateReturnTransform === undefined",
"score": 79.49517755328961
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " params: Parameters,\n obj: UpdatingObject\n ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(\n params: Parameters,\n obj: UpdatingObject\n ): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.run(params, obj as UpdatingObject);\n return;",
"score": 65.79768247940656
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(obj: UpdatingObject): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();",
"score": 64.60254246217002
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " }\n const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);\n const compiledQuery = this.instantiateWithReturns(params, transformedObj);\n const result = await this.db.executeQuery(compiledQuery);\n if (result.rows.length === 0) {\n return null;\n }\n return this.applyUpdateReturnTransform(\n obj as UpdatingObject,\n result.rows[0] as any",
"score": 60.91435828093222
}
] | typescript | .instantiateWithReturns({}, transformedObj); |
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningAll,
createUserMapperReturningDefault,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningAll>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningAll(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('deleting rows via TableMapper', () => {
it('accepts readonly filters', async () => {
const filter = { name: 'Not There' as const } as const;
await userMapper.delete(filter).run();
await userMapper.delete(filter).returnCount();
});
it("doesn't delete anything if no rows match", async () => {
const count = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(0);
const success = await userMapper.delete({ name: USERS[0].name }).run();
expect(success).toEqual(false);
});
it('deletes rows without returning a count', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const success = await testMapper.delete({ name: USERS[0].name }).run();
expect(success).toBe(true);
const users = await testMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count as bigint default', async () => {
const defaultMapper = createUserMapperReturningDefault(db);
const count1 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(BigInt(0));
await defaultMapper.insert().run(USERS);
const count2 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(BigInt(2));
const users = await defaultMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count inferred as a number', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const count = await testMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(2);
});
it('deletes rows returning the deletion count as number', async () => {
const count1 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes all rows without a filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper.delete().returnCount();
expect(count1).toEqual(3);
const users1 = await userMapper.select().returnAll();
expect(users1.length).toEqual(0);
await userMapper.insert().run(USERS);
const success = await userMapper.delete().run();
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
});
it('deletes rows specified via compound filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete(({ and, cmpr }) =>
and([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count1).toEqual(1);
const count2 = await userMapper
.delete(({ or, cmpr }) =>
or([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count2).toEqual(1);
});
it('deletes rows specified via binary operation', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete('name', '=', USERS[0].name)
.returnCount();
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('modifies a delete query builder', async () => {
await userMapper.insert().run(USERS);
await userMapper.insert().run({ ...USERS[1], handle: 'user4' });
const count1 = await userMapper
.delete()
.modify((qb) => qb.where('name', '=', USERS[0].name))
.returnCount();
expect(count1).toEqual(2);
const count2 = await userMapper
.delete({ name: USERS[1].name })
.modify((qb) => qb.where('handle', '=', 'user4'))
.returnCount();
expect(count2).toEqual(1);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
});
it('compiles an unparameterized delete query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.delete({ name: USERS[0].name }).compile();
const count1 = await compilation.returnCount({});
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
await userMapper.insert().run(USERS[2]);
const success = await compilation.run({});
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('parameterizes and compiles a delete query', async () => {
const parameterization = userMapper.parameterize<{ targetName: string }>(
({ mapper | , param }) => mapper.delete({ name: param('targetName') })
); |
const count1 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
const count3 = await parameterization.returnCount({
targetName: USERS[1].name,
});
expect(count3).toEqual(1);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.run({ notThere: 'foo' });
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.run({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.run({ targetName: 123 });
});
});
ignore('detects deletion type errors', async () => {
// @ts-expect-error - table must have all filter fields
userMapper.delete({ notThere: 'xyz' });
// @ts-expect-error - table must have all filter fields
userMapper.delete('notThere', '=', 'foo');
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via allOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapper.delete('str');
// @ts-expect-error - ID filter must have correct type
userMapper.delete(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete([1]);
});
});
| src/tests/delete.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " });\n it('selects via key column values', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting via key value\n const users1 = await userMapper.select(2).returnAll();\n expect(users1.length).toEqual(1);\n expect(users1[0].handle).toEqual(USERS[1].handle);\n // Test selecting via key tuple\n const users2 = await userMapper.select([2]).returnAll();\n expect(users2.length).toEqual(1);",
"score": 53.349524207418156
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users2[0].handle).toEqual(USERS[1].handle);\n });\n it('selects with a matching field filter', async () => {\n await userMapper.insert().run(USERS);\n let users = await userMapper\n .select({\n name: USERS[0].name,\n })\n .returnAll();\n expect(users.length).toEqual(2);",
"score": 50.62322243083253
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - errors on invalid column names\n users[0].notThere;\n // @ts-expect-error - errors on invalid column names\n user!.notThere;\n });\n });\n it('parameterizes and compiles a select query', async () => {\n await userMapper.insert().run(USERS);\n const parameterization = userMapper.parameterize<{ name: string }>(\n ({ mapper, param }) => mapper.select({ name: param('name') })",
"score": 49.63027430652466
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " );\n // test returnAll() returning multiple\n const users = await parameterization.returnAll({ name: USERS[0].name });\n expect(users.length).toEqual(2);\n expect(users[0].handle).toEqual(USERS[0].handle);\n expect(users[1].handle).toEqual(USERS[2].handle);\n // Ensure that the provided columns are not optional\n ((_: string) => {})(users[0].handle);\n // test returnAll() returning none\n const users2 = await parameterization.returnAll({ name: 'not there' });",
"score": 41.16758321489998
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " expect(users2.length).toEqual(0);\n // test returnOne() returning one\n const user = await parameterization.returnOne({ name: USERS[1].name });\n expect(user?.handle).toEqual(USERS[1].handle);\n // Ensure that the provided columns are not optional\n ((_: string) => {})(user!.name);\n // test returnOne() returning none\n const user2 = await parameterization.returnOne({ name: 'not there' });\n expect(user2).toBeNull();\n ignore('parameterization type errors', () => {",
"score": 38.84396824173653
}
] | typescript | , param }) => mapper.delete({ name: param('targetName') })
); |
import { Meta, StoryFn } from '@storybook/react';
import { Dialog, DialogProps } from '../lib-components/Dialog';
import { useState, useEffect } from 'react';
import { Button } from '@mui/material';
export default {
title: 'Components/Dialog',
component: Dialog,
argTypes: {
type: {
options: ['information', 'alert', 'decision', 'confirmation', 'error'],
control: { type: 'radio' }
},
visibility: {
name: 'visibility',
type: { name: 'boolean', required: false },
description: 'Boolean which defines the visibility of the Dialog.',
options: [true, false],
control: { type: 'boolean' }
}
}
} as Meta;
const TemplateMessage: StoryFn<DialogProps> = (args) => {
const [dialogVisibility, setDialogVisibility] = useState(
args.visibility ?? false
);
useEffect(() => {
setDialogVisibility(args.visibility ?? false);
}, [args.visibility]);
const dialogWithoutFunction = ['alert', 'information'];
return (
<div
style={{
position: 'absolute',
left: '45%',
top: '50%'
}}
>
<Button
sx={{ bottom: '18px' }}
onClick={() => setDialogVisibility(!dialogVisibility)}
>
Show Dialog
</Button>
{dialogWithoutFunction.includes(args.type) ? (
< | Dialog
{...args} |
visibility={dialogVisibility}
setVisibility={setDialogVisibility}
/>
) : (
<Dialog
{...args}
visibility={dialogVisibility}
rejectFunction={() => setDialogVisibility(!dialogVisibility)}
acceptFunction={() => setDialogVisibility(!dialogVisibility)}
/>
)}
</div>
);
};
export const DialogInformation = TemplateMessage.bind({});
DialogInformation.args = {
type: 'information',
title: 'Information Dialog Title',
children:
'DialogInformation appears in front of app content to provide additional information to the users.',
acceptLabel: 'Confirmar'
};
export const DialogAlert = TemplateMessage.bind({});
DialogAlert.args = {
type: 'alert',
title: 'Alert Message Title',
children:
'DialogAlert is an option to display important information through an alert message, ensuring that the user is aware of a critical information.'
};
export const DialogDecision = TemplateMessage.bind({});
DialogDecision.args = {
type: 'decision',
title: 'Decision Dialog Title',
children:
'DialogDecision presents a message to the user and includes a confirmation button and a cancel button, enabling the user to make a decision regarding a specific question.'
};
export const DialogConfirmation = TemplateMessage.bind({});
DialogConfirmation.args = {
type: 'confirmation',
title: 'Confirmation Dialog Title',
children:
'DialogConfirmation presents a message to the user and includes a confirmation button and a cancel button, ensuring that the user acknowledges the message.'
};
export const DialogError = TemplateMessage.bind({});
DialogError.args = {
type: 'error',
title: 'Error Dialog Title',
children:
'DialogError presents a message to the user and includes a confirmation button and a cancel button, ensuring that the user acknowledges the message.'
};
| src/stories/Dialog.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " <Button\n onClick={onHide}\n style={{ backgroundColor: color[type], color: '#ffffff' }}\n >\n {acceptLabel}\n </Button>\n ) : (\n <div>\n <Button onClick={rejectFunction} style={{ color: color[type] }}>\n {rejectLabel}",
"score": 19.311373922227382
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " </Button>\n <Button\n onClick={acceptFunction}\n style={{\n marginLeft: 10,\n backgroundColor: color[type],\n color: '#ffffff'\n }}\n >\n {acceptLabel}",
"score": 17.63033843673758
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " >\n {drawerVisibility ? 'Close SideMenu' : 'Open SideMenu'}\n </Button>\n </div>\n <SideMenu\n visibility={drawerVisibility}\n setVisibility={setDrawerVisibility}\n links={args.links}\n top={args.top}\n />",
"score": 16.81387006426069
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " height: '64px',\n display: 'flex',\n justifyContent: 'center',\n alignItems: 'center'\n }}\n >\n <Button\n type='button'\n variant='contained'\n onClick={() => setDrawerVisibility(!drawerVisibility)}",
"score": 13.70496773379268
},
{
"filename": "src/stories/Footer.stories.tsx",
"retrieved_chunk": " telephone={`${args.footerTelephone}`}\n telephoneComplement={`${args.footerTelephoneComplement}`}\n email={`${args.footerEmail}`}\n link={`${args.footerLink}`}\n textLink={`${args.footerLink}`}\n description={`${args.footerDescription}`}\n copyrightText={`${args.footerCopyrightText}`}\n signatureText={args.footerSignatureText}\n signatureLink={`${args.footerSignatureLink}`}\n largeFooter={args.footerLargeFooter}",
"score": 12.895482466843921
}
] | typescript | Dialog
{...args} |
import {
ComparisonOperatorExpression,
Kysely,
OperandValueExpressionOrList,
ReferenceExpression,
WhereInterface,
} from 'kysely';
import { SelectableColumnTuple } from './type-utils';
import { QueryFilter } from './query-filter';
type AnyWhereInterface = WhereInterface<any, any>;
/**
* Returns a query builder that constrains the provided query builder
* according to the provided query filter or binary operation.
* @param base The Kysely mapper that is used to create references.
* @param qb The query builder to constrain.
* @param filterOrLHS The query filter or left-hand side of a binary operation.
* @param op The operator of a binary operation.
* @param rhs The right-hand side of a binary operation.
* @returns A query builder constrained for the provided query filter
* or binary operation.
*/
export function applyQueryFilter<
DB,
TB extends keyof DB & string,
KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,
QB extends AnyWhereInterface,
RE extends ReferenceExpression<DB, TB>
>(
db: Kysely<DB>,
qb: QB,
keyColumns: KeyColumns,
filterOrLHS: QueryFilter<DB, TB, KeyColumns, RE> | RE,
op?: ComparisonOperatorExpression,
rhs?: OperandValueExpressionOrList<DB, TB, RE>
): QB {
// Process a binary operation.
if (op !== undefined) {
return qb.where(filterOrLHS as RE, op, rhs!) as QB;
}
const filter = filterOrLHS as QueryFilter<DB, TB, KeyColumns, RE>;
if (typeof filter === 'object') {
// Process a key tuple filter.
if (Array.isArray(filter)) {
keyColumns.forEach((column, i) => {
qb = qb.where(db.dynamic.ref(column), '=', filter[i]) as QB;
});
return qb;
}
// Process a query expression filter. Check for expressions
// first because they could potentially be plain objects.
if ('expressionType' in filter) {
return qb.where(filter) as QB;
}
// Process a field matching filter. `{}` matches all rows.
if (filter.constructor === Object) {
for (const [column, value] of Object.entries(filter)) {
if (Array.isArray(value)) {
qb = qb.where(db.dynamic.ref(column), 'in', value) as QB;
} else {
qb = qb.where(db.dynamic.ref(column), '=', value) as QB;
}
}
return qb as unknown as QB;
}
}
// Process a where expression factory.
if (typeof filter === 'function') {
return qb.where(filter as any) as QB;
}
// Process a single key filter, expressed as a primitive value.
if (keyColumns.length === 1) {
| return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) as QB; |
}
throw Error('Unrecognized query filter');
}
| src/lib/apply-query-filter.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/compiling-values-query.ts",
"retrieved_chunk": " }\n private getReturningQB(): QB {\n return this.returnColumns[0 as number] == '*'\n ? (this.qb!.returningAll() as QB)\n : (this.qb!.returning(\n this.returnColumns as Readonly<(keyof Selectable<DB[TB]> & string)[]>\n ) as QB);\n }\n private instantiate(\n compiledQuery: CompiledQuery<any>,",
"score": 47.04953053901853
},
{
"filename": "src/lib/query-filter.ts",
"retrieved_chunk": " WhereExpressionFactory,\n} from 'kysely';\nimport { KeyTuple, SelectableColumnTuple } from './type-utils';\n/**\n * Type of the query filter object, which can be passed as an argument\n * to query functions to constrain results. A filter can be any of the\n * following:\n *\n * - A key column value, which matches a single key column, if\n * `KeyColumns` is a tuple with a single element.",
"score": 44.62281276860791
},
{
"filename": "src/mappers/entire-row-transforms.ts",
"retrieved_chunk": " obj: Selectable<DB[TB]>,\n _columns: Readonly<(keyof Insertable<DB[TB]>)[]> | ['*']\n ) {\n const insertedValues = { ...obj };\n this.keyColumns.forEach((column) => {\n if (!obj[column as unknown as keyof Selectable<DB[TB]>]) {\n delete insertedValues[column as unknown as keyof Selectable<DB[TB]>];\n }\n });\n return insertedValues as unknown as Insertable<DB[TB]>;",
"score": 40.295216928056426
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " const parameterizedValues = this.getParameterizedObject(columnsToInsert);\n this.qb = qb.values(parameterizedValues) as QB;\n }\n /**\n * Inserts the provided object into the table as a row, first transforming\n * it into a row via `insertTransform` (if defined). Also retrieves the\n * columns specified in `returnColumns`, returning them to the caller as\n * `InsertReturn`, after transformation by `insertReturnTransform`.\n * If `returnColumns` is empty, returns `undefined`.\n *",
"score": 37.36114766073058
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " ) {\n this.keyColumns = settings.keyColumns ?? ([] as any);\n this.selectedColumns =\n settings.selectedColumns === undefined\n ? ([] as any)\n : settings.selectedColumns[0] === '*'\n ? ([] as any)\n : settings.selectedColumns;\n this.insertReturnColumns =\n settings.insertReturnColumns ?? this.keyColumns ?? ([] as any);",
"score": 35.8297967408013
}
] | typescript | return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) as QB; |
import { useState } from 'react';
import { SideMenu } from '../components/SideMenu';
import { BrowserRouter } from 'react-router-dom';
import { Meta, StoryFn } from '@storybook/react';
import { testLinks } from './sampledata/SampleData';
import { SideMenuLink } from '../interfaces';
import { Button } from '@mui/material';
export default {
title: 'Components/SideMenu',
component: SideMenu,
parameters: {
docs: {
page: null
}
},
argTypes: {
visibility: {
name: 'visibility',
control: { disable: true },
description: 'Boolean which defines the visibility of sidemenu.',
table: {
category: 'SideMenu'
}
},
top: {
name: 'top',
description: 'Top spacing of sidemenu to top of your page.',
table: {
category: 'SideMenu'
}
},
setVisibility: {
name: 'setVisibility',
control: { disable: true },
description:
'useState set function passed to define the visibility of sidemenu in actions.',
table: {
category: 'SideMenu'
}
},
links: {
name: 'links',
description: 'Array of links which defines the custom side menu',
table: {
category: 'SideMenu'
}
}
}
} as Meta;
interface SideMenuStoryProps {
links: SideMenuLink[];
top: string;
}
const Template: StoryFn<SideMenuStoryProps> = (args) => {
const [drawerVisibility, setDrawerVisibility] = useState<boolean>(false);
return (
<BrowserRouter>
<div
style={{
width: '100%',
height: '64px',
display: 'flex',
justifyContent: 'center',
alignItems: 'center'
}}
>
<Button
type='button'
variant='contained'
onClick={() => setDrawerVisibility(!drawerVisibility)}
>
{drawerVisibility ? 'Close SideMenu' : 'Open SideMenu'}
</Button>
</div>
| <SideMenu
visibility={drawerVisibility} |
setVisibility={setDrawerVisibility}
links={args.links}
top={args.top}
/>
</BrowserRouter>
);
};
export const SideMenu_ = Template.bind({});
SideMenu_.args = {
links: testLinks,
top: '64px'
};
| src/stories/SideMenu.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " );\n } else {\n return <></>;\n }\n}\nexport function SideMenu({\n links,\n top,\n visibility = false,\n setVisibility",
"score": 22.749595000394855
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " <Button\n onClick={onHide}\n style={{ backgroundColor: color[type], color: '#ffffff' }}\n >\n {acceptLabel}\n </Button>\n ) : (\n <div>\n <Button onClick={rejectFunction} style={{ color: color[type] }}>\n {rejectLabel}",
"score": 20.653402022923807
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " </StyledToolbar>\n </StyledAppBar>\n {children !== undefined ? (\n children\n ) : (\n <SideMenu\n visibility={sideMenuIsOpen}\n top={'64px'}\n setVisibility={handleToggleSideMenu}\n links={sideMenuLinks}",
"score": 20.536152968793964
},
{
"filename": "src/lib-components/ForbiddenPage/index.tsx",
"retrieved_chunk": " backgroundColor: '#DADADA',\n borderColor: '#DADADA'\n }\n }}\n onClick={logout}\n variant='outlined'\n startIcon={<LogoutIcon />}\n >\n Log out\n </Button>",
"score": 18.259720459073677
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </PositionsContainer>\n )}\n <LogoutButton\n variant='text'\n type='button'\n onClick={() => {\n logoutFunction();\n }}\n >\n Sair",
"score": 18.012313648799257
}
] | typescript | <SideMenu
visibility={drawerVisibility} |
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningAll,
createUserMapperReturningDefault,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningAll>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningAll(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('deleting rows via TableMapper', () => {
it('accepts readonly filters', async () => {
const filter = { name: 'Not There' as const } as const;
await userMapper.delete(filter).run();
await userMapper.delete(filter).returnCount();
});
it("doesn't delete anything if no rows match", async () => {
const count = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(0);
const success = await userMapper.delete({ name: USERS[0].name }).run();
expect(success).toEqual(false);
});
it('deletes rows without returning a count', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const success = await testMapper.delete({ name: USERS[0].name }).run();
expect(success).toBe(true);
const users = await testMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count as bigint default', async () => {
const defaultMapper = createUserMapperReturningDefault(db);
const count1 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(BigInt(0));
await defaultMapper.insert().run(USERS);
const count2 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(BigInt(2));
const users = await defaultMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count inferred as a number', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const count = await testMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(2);
});
it('deletes rows returning the deletion count as number', async () => {
const count1 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes all rows without a filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper.delete().returnCount();
expect(count1).toEqual(3);
const users1 = await userMapper.select().returnAll();
expect(users1.length).toEqual(0);
await userMapper.insert().run(USERS);
const success = await userMapper.delete().run();
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
});
it('deletes rows specified via compound filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete(({ and, cmpr }) =>
and([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count1).toEqual(1);
const count2 = await userMapper
.delete(({ or, cmpr }) =>
or([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count2).toEqual(1);
});
it('deletes rows specified via binary operation', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete('name', '=', USERS[0].name)
.returnCount();
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('modifies a delete query builder', async () => {
await userMapper.insert().run(USERS);
await userMapper.insert().run({ ...USERS[1], handle: 'user4' });
const count1 = await userMapper
.delete()
.modify((qb) => qb.where('name', '=', USERS[0].name))
.returnCount();
expect(count1).toEqual(2);
const count2 = await userMapper
.delete({ name: USERS[1].name })
.modify((qb) => qb.where('handle', '=', 'user4'))
.returnCount();
expect(count2).toEqual(1);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
});
it('compiles an unparameterized delete query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.delete({ name: USERS[0].name }).compile();
const count1 = await compilation.returnCount({});
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
await userMapper.insert().run(USERS[2]);
const success = await compilation.run({});
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('parameterizes and compiles a delete query', async () => {
const parameterization = userMapper.parameterize<{ targetName: string }>(
( | { mapper, param }) => mapper.delete({ name: param('targetName') })
); |
const count1 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
const count3 = await parameterization.returnCount({
targetName: USERS[1].name,
});
expect(count3).toEqual(1);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.run({ notThere: 'foo' });
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.run({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.run({ targetName: 123 });
});
});
ignore('detects deletion type errors', async () => {
// @ts-expect-error - table must have all filter fields
userMapper.delete({ notThere: 'xyz' });
// @ts-expect-error - table must have all filter fields
userMapper.delete('notThere', '=', 'foo');
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via allOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapper.delete('str');
// @ts-expect-error - ID filter must have correct type
userMapper.delete(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete([1]);
});
});
| src/tests/delete.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " });\n it('selects via key column values', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting via key value\n const users1 = await userMapper.select(2).returnAll();\n expect(users1.length).toEqual(1);\n expect(users1[0].handle).toEqual(USERS[1].handle);\n // Test selecting via key tuple\n const users2 = await userMapper.select([2]).returnAll();\n expect(users2.length).toEqual(1);",
"score": 53.349524207418156
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users2[0].handle).toEqual(USERS[1].handle);\n });\n it('selects with a matching field filter', async () => {\n await userMapper.insert().run(USERS);\n let users = await userMapper\n .select({\n name: USERS[0].name,\n })\n .returnAll();\n expect(users.length).toEqual(2);",
"score": 50.62322243083253
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - errors on invalid column names\n users[0].notThere;\n // @ts-expect-error - errors on invalid column names\n user!.notThere;\n });\n });\n it('parameterizes and compiles a select query', async () => {\n await userMapper.insert().run(USERS);\n const parameterization = userMapper.parameterize<{ name: string }>(\n ({ mapper, param }) => mapper.select({ name: param('name') })",
"score": 49.63027430652466
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " );\n // test returnAll() returning multiple\n const users = await parameterization.returnAll({ name: USERS[0].name });\n expect(users.length).toEqual(2);\n expect(users[0].handle).toEqual(USERS[0].handle);\n expect(users[1].handle).toEqual(USERS[2].handle);\n // Ensure that the provided columns are not optional\n ((_: string) => {})(users[0].handle);\n // test returnAll() returning none\n const users2 = await parameterization.returnAll({ name: 'not there' });",
"score": 41.16758321489998
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " expect(users2.length).toEqual(0);\n // test returnOne() returning one\n const user = await parameterization.returnOne({ name: USERS[1].name });\n expect(user?.handle).toEqual(USERS[1].handle);\n // Ensure that the provided columns are not optional\n ((_: string) => {})(user!.name);\n // test returnOne() returning none\n const user2 = await parameterization.returnOne({ name: 'not there' });\n expect(user2).toBeNull();\n ignore('parameterization type errors', () => {",
"score": 38.84396824173653
}
] | typescript | { mapper, param }) => mapper.delete({ name: param('targetName') })
); |
import { UserPopup } from '../components/UserPopup';
import './storiesGlobals.css';
import { testUser } from './sampledata/SampleData';
import { Meta, StoryFn } from '@storybook/react';
import { User } from '../interfaces/index';
import { Dialog } from '../lib-components/Dialog';
import { useState } from 'react';
export default {
title: 'Components/UserPopup',
component: UserPopup,
argTypes: {
user: {
name: 'user',
control: 'object',
description: 'Object which defines user info'
},
logoutMethod: {
name: 'logoutMethod',
type: 'function',
description: 'Function which defines the lougout method for the page'
},
keycloak: {
name: 'keycloak',
description: 'Keycloak instance passed to UserPopup component',
control: { disable: true }
},
accountManagementUrl: {
name: 'accountManagementUrl',
description:
'Url that redirects to account management page of the system',
control: { disable: true }
}
}
} as Meta;
interface UserPopupStory {
user?: User;
}
const Template: StoryFn<UserPopupStory> = ({ user }) => {
const [visibility, setVisibility] = useState<boolean>(false);
return (
<>
<Dialog
type='information'
title='Logout Method '
children='This is a mocked logout. The logout method prop is a method that apply your custom logout to the system.'
acceptLabel='Understood'
visibility={visibility}
setVisibility={setVisibility}
/>
| <UserPopup
logoutMethod={() => { |
setVisibility(true);
}}
user={user}
auth={undefined}
accountManagementUrl='#'
/>
</>
);
};
export const UserPopup_ = Template.bind({});
UserPopup_.args = {
user: testUser
};
| src/stories/UserPopup.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " type: 'alert',\n title: 'Alert Message Title',\n children:\n 'DialogAlert is an option to display important information through an alert message, ensuring that the user is aware of a critical information.'\n};\nexport const DialogDecision = TemplateMessage.bind({});\nDialogDecision.args = {\n type: 'decision',\n title: 'Decision Dialog Title',\n children:",
"score": 34.423186759371724
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": "export const Dialog = ({\n type,\n title,\n children,\n visibility = false,\n setVisibility,\n acceptLabel = 'Ok',\n rejectLabel = 'Cancelar',\n acceptFunction,\n rejectFunction",
"score": 31.564003257064314
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": "DialogError.args = {\n type: 'error',\n title: 'Error Dialog Title',\n children:\n 'DialogError presents a message to the user and includes a confirmation button and a cancel button, ensuring that the user acknowledges the message.'\n};",
"score": 27.10653618560073
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " >\n Show Dialog\n </Button>\n {dialogWithoutFunction.includes(args.type) ? (\n <Dialog\n {...args}\n visibility={dialogVisibility}\n setVisibility={setDialogVisibility}\n />\n ) : (",
"score": 24.50565423188552
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';\n title: string;\n children: JSX.Element | string;\n visibility?: boolean;\n setVisibility: React.Dispatch<React.SetStateAction<boolean>>;\n acceptLabel?: string;\n rejectLabel?: string;\n acceptFunction?: () => void;\n rejectFunction?: () => void;\n}",
"score": 24.500230057240717
}
] | typescript | <UserPopup
logoutMethod={() => { |
import {
ComparisonOperatorExpression,
Kysely,
OperandValueExpressionOrList,
ReferenceExpression,
WhereInterface,
} from 'kysely';
import { SelectableColumnTuple } from './type-utils';
import { QueryFilter } from './query-filter';
type AnyWhereInterface = WhereInterface<any, any>;
/**
* Returns a query builder that constrains the provided query builder
* according to the provided query filter or binary operation.
* @param base The Kysely mapper that is used to create references.
* @param qb The query builder to constrain.
* @param filterOrLHS The query filter or left-hand side of a binary operation.
* @param op The operator of a binary operation.
* @param rhs The right-hand side of a binary operation.
* @returns A query builder constrained for the provided query filter
* or binary operation.
*/
export function applyQueryFilter<
DB,
TB extends keyof DB & string,
KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,
QB extends AnyWhereInterface,
RE extends ReferenceExpression<DB, TB>
>(
db: Kysely<DB>,
qb: QB,
keyColumns: KeyColumns,
filterOrLHS: QueryFilter<DB, TB, KeyColumns, RE> | RE,
op?: ComparisonOperatorExpression,
rhs?: OperandValueExpressionOrList<DB, TB, RE>
): QB {
// Process a binary operation.
if (op !== undefined) {
return qb.where(filterOrLHS as RE, op, rhs!) as QB;
}
const filter = filterOrLHS as QueryFilter<DB, TB, KeyColumns, RE>;
if (typeof filter === 'object') {
// Process a key tuple filter.
if (Array.isArray(filter)) {
keyColumns.forEach((column, i) => {
qb = qb.where(db.dynamic.ref(column), '=', filter[i]) as QB;
});
return qb;
}
// Process a query expression filter. Check for expressions
// first because they could potentially be plain objects.
if ('expressionType' in filter) {
return qb.where(filter) as QB;
}
// Process a field matching filter. `{}` matches all rows.
if (filter.constructor === Object) {
for (const [column, value] of Object.entries(filter)) {
if (Array.isArray(value)) {
qb = qb.where(db.dynamic.ref(column), 'in', value) as QB;
} else {
qb = qb.where(db.dynamic.ref(column), '=', value) as QB;
}
}
return qb as unknown as QB;
}
}
// Process a where expression factory.
if (typeof filter === 'function') {
return qb.where(filter as any) as QB;
}
// Process a single key filter, expressed as a primitive value.
| if (keyColumns.length === 1) { |
return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) as QB;
}
throw Error('Unrecognized query filter');
}
| src/lib/apply-query-filter.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/lib/query-filter.ts",
"retrieved_chunk": " WhereExpressionFactory,\n} from 'kysely';\nimport { KeyTuple, SelectableColumnTuple } from './type-utils';\n/**\n * Type of the query filter object, which can be passed as an argument\n * to query functions to constrain results. A filter can be any of the\n * following:\n *\n * - A key column value, which matches a single key column, if\n * `KeyColumns` is a tuple with a single element.",
"score": 40.21047932161464
},
{
"filename": "src/queries/compiling-values-query.ts",
"retrieved_chunk": " }\n private getReturningQB(): QB {\n return this.returnColumns[0 as number] == '*'\n ? (this.qb!.returningAll() as QB)\n : (this.qb!.returning(\n this.returnColumns as Readonly<(keyof Selectable<DB[TB]> & string)[]>\n ) as QB);\n }\n private instantiate(\n compiledQuery: CompiledQuery<any>,",
"score": 34.477806327379916
},
{
"filename": "src/mappers/entire-row-transforms.ts",
"retrieved_chunk": " obj: Selectable<DB[TB]>,\n _columns: Readonly<(keyof Insertable<DB[TB]>)[]> | ['*']\n ) {\n const insertedValues = { ...obj };\n this.keyColumns.forEach((column) => {\n if (!obj[column as unknown as keyof Selectable<DB[TB]>]) {\n delete insertedValues[column as unknown as keyof Selectable<DB[TB]>];\n }\n });\n return insertedValues as unknown as Insertable<DB[TB]>;",
"score": 33.119759046939386
},
{
"filename": "src/lib/query-filter.ts",
"retrieved_chunk": " * - A key tuple, which matches multiple key columns, if `KeyColumns`\n * is a tuple with multiple elements.\n * - An object, which matches columns against the object's fields. A\n * field value may be an array, in which case the associated column ]\n * matches any of the elements of the array.\n * - A raw SQL expression using Kysely's `sql` template literal tag.\n * - An arbitrary Kysely query expression.\n *\n * A filter is represented as a single value, but the methods that use\n * filters also accept three-argument binary operations.",
"score": 32.70567104933693
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " const parameterizedValues = this.getParameterizedObject(columnsToInsert);\n this.qb = qb.values(parameterizedValues) as QB;\n }\n /**\n * Inserts the provided object into the table as a row, first transforming\n * it into a row via `insertTransform` (if defined). Also retrieves the\n * columns specified in `returnColumns`, returning them to the caller as\n * `InsertReturn`, after transformation by `insertReturnTransform`.\n * If `returnColumns` is empty, returns `undefined`.\n *",
"score": 30.330534512211884
}
] | typescript | if (keyColumns.length === 1) { |
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningNothing,
} from './utils/test-mappers';
let db: Kysely<Database>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting specific columns', () => {
it('subsets inserted columns, excluding ID', async () => {
const subsetQuery = userMapperReturningID
.insert()
.columns(['name', 'handle'] as const); // allows readonly array
const insertReturn = await subsetQuery.returnOne({
id: 10,
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
expect(insertReturn).toEqual({ id: expect.any(Number) });
const readUser = await userMapperReturningID.select().returnAll();
expect(readUser).toEqual([
{ id: 1, name: 'John Doe', handle: 'johndoe', email: null },
]);
});
it('subsets inserted columns, including ID', async () => {
const subsetQuery = userMapperReturningNothing
.insert()
.columns(['id', 'name', 'handle']);
await subsetQuery.run({
id: 10,
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
const readUser = await userMapperReturningID.select().returnAll();
expect(readUser).toEqual([
{ id: 10, name: 'John Doe', handle: 'johndoe', email: null },
]);
});
it('requires all subsetted columns to be inserted', async () => {
const subsetQuery = userMapperReturningID
.insert()
.columns(['name', 'handle', 'email']);
const insertValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => subsetQuery.returnOne(insertValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await subsetQuery.run({ ...insertValues, email: null });
expect(success).toBe(true);
});
it('provides insertTransform with column subset', async () => {
expect.assertions(1);
const mapper = userMapperReturningID.withTransforms({
| insertTransform: (source, columns) => { |
expect(columns).toEqual(['name', 'handle']);
return source;
},
});
await mapper.insert().columns(['name', 'handle']).run({
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
});
});
| src/tests/insert-columns.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " const success = await subsetQuery.run({ ...updateValues, email: null });\n expect(success).toBe(true);\n });\n it('provides updateTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = new TableMapper(db, 'users').withTransforms({\n updateTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },",
"score": 73.89623919767659
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(\n `column 'email' missing`\n );\n const success = await compilation.run({}, { ...updateValues, email: null });\n expect(success).toBe(true);\n });\n});",
"score": 62.38205049052876
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " const success = await compilation.run({ ...insertValues, email: null });\n expect(success).toBe(true);\n });\n});",
"score": 53.74302773852454
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " });\n it('requires all indicated columns to be inserted', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n const insertValues = { name: 'John Doe', handle: 'johndoe' };\n expect(() => compilation.returnOne(insertValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 50.734899909465526
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " });\n it('requires all subsetted columns to be updated', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { name: 'Sue Rex' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['name', 'email']);\n expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 47.23401624008414
}
] | typescript | insertTransform: (source, columns) => { |
import { Meta, StoryFn } from '@storybook/react';
import ScopedCssBaseline from '@mui/material/ScopedCssBaseline/ScopedCssBaseline';
import './storiesGlobals.css';
import { Page } from '../lib-components/Page';
import { SideMenuLink, System, User } from '@/interfaces';
import { testLinks, testSystems, testUser } from './sampledata/SampleData';
import { BrowserRouter } from 'react-router-dom';
import EngineeringIcon from '@mui/icons-material/Engineering';
import { JSXElementConstructor } from 'react';
import { footerArgTypes, navbarArgTypes } from './utils/argTypes';
export default {
title: 'Components/Page',
parameters: {
docs: {
page: null
}
},
argTypes: {
navbar: {
table: {
disable: true
}
},
footer: {
table: {
disable: true
}
},
centralized: {
name: 'centralized',
type: { name: 'boolean', required: false },
description:
'Boolean which defines if the content of page is centralized or not.',
options: [true, false],
control: { type: 'boolean' }
},
...footerArgTypes,
...navbarArgTypes,
width: {
name: 'width',
type: { name: 'string', required: false },
description: "String wich defines children's width",
control: { type: 'text' },
table: {
category: 'Children'
}
},
height: {
name: 'height',
type: { name: 'string', required: false },
description: "String wich defines children's height",
control: { type: 'text' },
table: {
category: 'Children'
}
},
color: {
name: 'color',
type: { name: 'string', required: false },
description: "String wich defines children's color",
control: { type: 'color' },
table: {
category: 'Children'
}
}
}
} as Meta;
interface StoryPageProps {
isLandingPage: boolean;
haveSearchBar: boolean;
hiddenUser: boolean;
user: User;
h1: boolean;
sideMenuLinks: SideMenuLink[];
systemsListPopup: boolean;
systemsList: System[];
IconComponent: JSXElementConstructor<any>;
title: string;
footerTitle: string;
footerTelephone: string;
footerTelephoneComplement: string;
footerEmail: string;
footerLink: string;
footerTextLink: string;
footerDescription: string;
footerCopyrightText: string;
width: string;
height: string;
color: string;
centralized: boolean;
}
interface IconComponentProps {
haveIcon: JSXElementConstructor<any>;
}
const IconComponent = ({ haveIcon }: IconComponentProps) => {
if (!haveIcon) {
return <></>;
} else {
return <EngineeringIcon />;
}
};
const Template: StoryFn<StoryPageProps> = (args) => {
return (
<ScopedCssBaseline>
<BrowserRouter>
< | Page
navbar={{ |
isLandingPage: args.isLandingPage,
haveSearchBar: args.haveSearchBar ? true : false,
hiddenUser: args.hiddenUser,
user: args.hiddenUser ? undefined : args.user,
h1: args.h1,
children: undefined,
title: args.title,
sideMenuLinks: args.sideMenuLinks,
systemsList: args.systemsList ? args.systemsList : undefined,
IconComponent
}}
footer={{
title: args.footerTitle,
telephone: args.footerTelephone,
telephoneComplement: args.footerTelephoneComplement,
email: args.footerEmail,
link: args.footerLink,
textLink: args.footerTextLink,
description: args.footerDescription,
copyrightText: args.footerCopyrightText
}}
centralized={args.centralized}
createNavbarContext={false}
>
<div
style={{
width: `${args.width}`,
height: `${args.height}`,
color: `${args.color}`,
backgroundColor: `${args.color}`,
padding: '20px 40px'
}}
></div>
</Page>
</BrowserRouter>
</ScopedCssBaseline>
);
};
export const Page_ = Template.bind({});
Page_.args = {
width: '150px',
height: '150px',
color: '#000000',
title: 'Cinnamon',
h1: true,
isLandingPage: false,
haveSearchBar: true,
hiddenUser: false,
user: testUser,
sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
footerTitle: 'FOOTER TITLE',
footerTelephone: '(xx) xxxx-xxxx',
footerTelephoneComplement: 'Internal number: xxxx / xxxx',
footerEmail: '[email protected]',
footerLink: 'https://www.google.com',
footerTextLink: 'Site',
footerDescription: "Footer's description with \n line break",
footerCopyrightText: 'CIn UFPE | All rights reserved'
};
| src/stories/Page.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " }\n};\nconst Template: StoryFn<NavbarStoryProps> = (args) => {\n return (\n <BrowserRouter>\n <Navbar\n isLandingPage={args.isLandingPage}\n haveSearchBar={args.haveSearchBar}\n hiddenUser={args.hiddenUser}\n user={args.hiddenUser ? undefined : args.user}",
"score": 20.28848295385886
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " links: SideMenuLink[];\n top: string;\n}\nconst Template: StoryFn<SideMenuStoryProps> = (args) => {\n const [drawerVisibility, setDrawerVisibility] = useState<boolean>(false);\n return (\n <BrowserRouter>\n <div\n style={{\n width: '100%',",
"score": 18.37112096065192
},
{
"filename": "src/stories/Footer.stories.tsx",
"retrieved_chunk": " footerDescription: string;\n footerCopyrightText: string;\n footerSignatureText: string;\n footerSignatureLink: string;\n footerLargeFooter: boolean;\n}\nconst Template: StoryFn<FooterStoryProps> = (args) => {\n return (\n <Footer\n title={`${args.footerTitle}`}",
"score": 15.796538908212389
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " </BrowserRouter>\n );\n};\nexport const SideMenu_ = Template.bind({});\nSideMenu_.args = {\n links: testLinks,\n top: '64px'\n};",
"score": 13.745264527409358
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": " h1={args.h1}\n title={args.title}\n sideMenuLinks={args.sideMenuLinks}\n systemsList={args.systemsListPopup ? args.systemsList : undefined}\n IconComponent={IconComponent}\n />\n </BrowserRouter>\n );\n};\nexport const Navbar_ = Template.bind({});",
"score": 13.442743301030074
}
] | typescript | Page
navbar={{ |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
| this.qb = qb.set(parameterizedValues) as QB; |
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.instantiateNoReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
| src/queries/compiling-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " const parameterizedValues = this.getParameterizedObject(columnsToInsert);\n this.qb = qb.values(parameterizedValues) as QB;\n }\n /**\n * Inserts the provided object into the table as a row, first transforming\n * it into a row via `insertTransform` (if defined). Also retrieves the\n * columns specified in `returnColumns`, returning them to the caller as\n * `InsertReturn`, after transformation by `insertReturnTransform`.\n * If `returnColumns` is empty, returns `undefined`.\n *",
"score": 40.29230013024334
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn,\n Parameters\n > {\n return new CompilingMappingUpdateQuery(\n this.db,\n this.qb,\n this.columnsToUpdate,",
"score": 34.28808841644377
},
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n > {\n return new SubsettingMappingUpdateQuery(\n this.db,\n this.qb,\n columnsToUpdate,\n this.transforms,\n this.returnColumns\n );",
"score": 33.1616440413593
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(obj: UpdatingObject): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();",
"score": 31.209458321001428
},
{
"filename": "src/queries/compiling-values-query.ts",
"retrieved_chunk": " }\n private getReturningQB(): QB {\n return this.returnColumns[0 as number] == '*'\n ? (this.qb!.returningAll() as QB)\n : (this.qb!.returning(\n this.returnColumns as Readonly<(keyof Selectable<DB[TB]> & string)[]>\n ) as QB);\n }\n private instantiate(\n compiledQuery: CompiledQuery<any>,",
"score": 31.053309809084322
}
] | typescript | this.qb = qb.set(parameterizedValues) as QB; |
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningAll,
createUserMapperReturningDefault,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningAll>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningAll(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('deleting rows via TableMapper', () => {
it('accepts readonly filters', async () => {
const filter = { name: 'Not There' as const } as const;
await userMapper.delete(filter).run();
await userMapper.delete(filter).returnCount();
});
it("doesn't delete anything if no rows match", async () => {
const count = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(0);
const success = await userMapper.delete({ name: USERS[0].name }).run();
expect(success).toEqual(false);
});
it('deletes rows without returning a count', async () => {
| const testMapper = new TableMapper(db, 'users').withTransforms({ |
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const success = await testMapper.delete({ name: USERS[0].name }).run();
expect(success).toBe(true);
const users = await testMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count as bigint default', async () => {
const defaultMapper = createUserMapperReturningDefault(db);
const count1 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(BigInt(0));
await defaultMapper.insert().run(USERS);
const count2 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(BigInt(2));
const users = await defaultMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count inferred as a number', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const count = await testMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(2);
});
it('deletes rows returning the deletion count as number', async () => {
const count1 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes all rows without a filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper.delete().returnCount();
expect(count1).toEqual(3);
const users1 = await userMapper.select().returnAll();
expect(users1.length).toEqual(0);
await userMapper.insert().run(USERS);
const success = await userMapper.delete().run();
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
});
it('deletes rows specified via compound filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete(({ and, cmpr }) =>
and([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count1).toEqual(1);
const count2 = await userMapper
.delete(({ or, cmpr }) =>
or([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count2).toEqual(1);
});
it('deletes rows specified via binary operation', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete('name', '=', USERS[0].name)
.returnCount();
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('modifies a delete query builder', async () => {
await userMapper.insert().run(USERS);
await userMapper.insert().run({ ...USERS[1], handle: 'user4' });
const count1 = await userMapper
.delete()
.modify((qb) => qb.where('name', '=', USERS[0].name))
.returnCount();
expect(count1).toEqual(2);
const count2 = await userMapper
.delete({ name: USERS[1].name })
.modify((qb) => qb.where('handle', '=', 'user4'))
.returnCount();
expect(count2).toEqual(1);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
});
it('compiles an unparameterized delete query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.delete({ name: USERS[0].name }).compile();
const count1 = await compilation.returnCount({});
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
await userMapper.insert().run(USERS[2]);
const success = await compilation.run({});
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('parameterizes and compiles a delete query', async () => {
const parameterization = userMapper.parameterize<{ targetName: string }>(
({ mapper, param }) => mapper.delete({ name: param('targetName') })
);
const count1 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
const count3 = await parameterization.returnCount({
targetName: USERS[1].name,
});
expect(count3).toEqual(1);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.run({ notThere: 'foo' });
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.run({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.run({ targetName: 123 });
});
});
ignore('detects deletion type errors', async () => {
// @ts-expect-error - table must have all filter fields
userMapper.delete({ notThere: 'xyz' });
// @ts-expect-error - table must have all filter fields
userMapper.delete('notThere', '=', 'foo');
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via allOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapper.delete('str');
// @ts-expect-error - ID filter must have correct type
userMapper.delete(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete([1]);
});
});
| src/tests/delete.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " users = await userMapper\n .select(userMapper.ref('email'), '=', 'nonexistent')\n .returnAll();\n expect(users.length).toEqual(0);\n });\n it('selects with a query expression filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper\n .select(sql`name != ${USERS[0].name}`)\n .returnAll();",
"score": 41.78782019132846
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting a single object without transformation', () => {\n it('inserts one returning no columns by default', async () => {\n const success = await userMapperReturningDefault.insert().run(USERS[0]);\n expect(success).toBe(true);\n const readUser0 = await userMapperReturningAll\n .select('email', '=', USERS[0].email!)\n .returnOne();",
"score": 41.02535067158563
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users2[0].handle).toEqual(USERS[1].handle);\n });\n it('selects with a matching field filter', async () => {\n await userMapper.insert().run(USERS);\n let users = await userMapper\n .select({\n name: USERS[0].name,\n })\n .returnAll();\n expect(users.length).toEqual(2);",
"score": 40.966615940431346
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " // test deleting a user\n const deleted = await userMapper.delete({ id: insertReturn1.id }).run();\n expect(deleted).toEqual(true);\n const selectedUser5 = await userMapper\n .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser5).toBeNull();\n });\n it('inserts/updates/deletes with all custom transforms', async () => {\n class MappedUser {",
"score": 40.03794476486576
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " it('selects with a binary operation filter using .ref()', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting by condition (with results)\n let users = await userMapper\n .select(userMapper.ref('name'), '=', USERS[0].name)\n .returnAll();\n expect(users.length).toEqual(2);\n expect(users[0].handle).toEqual(USERS[0].handle);\n expect(users[1].handle).toEqual(USERS[2].handle);\n // Test selecting by condition (no results)",
"score": 39.851347350619534
}
] | typescript | const testMapper = new TableMapper(db, 'users').withTransforms({ |
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this | .instantiateNoReturns({}, transformedObj); |
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
| src/queries/compiling-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * Runs the query, inserting rows into the table without returning any columns.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(objOrObjs: InsertedObject | InsertedObject[]): Promise<boolean> {\n await this.loadInsertedObjects(this.qb, objOrObjs).execute();\n return true;\n }\n /**\n * Returns an array of the columns to be inserted, with",
"score": 77.5250843305243
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " );\n }\n /**\n * Runs the query, updating rows, without returning any columns. Accepts\n * values for any parameters embedded in the query.\n *\n * On the first execution, compiles and discards the underlying Kysely\n * query builder. Subsequent executions reuse the compiled query.\n * @param obj The object which which to update the rows.\n * @returns `true` if any rows were updated, `false` otherwise.",
"score": 64.92316620253301
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " /**\n * Runs the query, returning the number of rows updated, in the required\n * client representation. Accepts values for any parameters embedded in\n * the query.\n *\n * On the first execution, compiles and discards the underlying Kysely\n * query builder. Subsequent executions reuse the compiled query.\n * @param obj The object which which to update the rows.\n * @returns Number of rows updated, in client-requested representation.\n */",
"score": 60.21104275230616
},
{
"filename": "src/queries/compiling-delete-query.ts",
"retrieved_chunk": " ) {\n this.#parameterizedQuery = new ParameterizedQuery(qb);\n }\n /**\n * Runs the query, returning the number of rows deleted, converted to\n * the required client representation. Accepts values for any parameters\n * embedded in the query.\n *\n * On the first execution, compiles and discards the underlying Kysely\n * query builder. Subsequent executions reuse the compiled query.",
"score": 57.59148565623327
},
{
"filename": "src/queries/compiling-select-query.ts",
"retrieved_chunk": " * Accepts values for any parameters embedded in the query.\n *\n * On the first execution, compiles and discards the underlying Kysely\n * query builder. Subsequent executions reuse the compiled query.\n * @param params Record characterizing the parameter names and types.\n * Pass in `{}` if the query has no parameters.\n * @returns An array of objects for the selected rows, possibly empty.\n */\n async returnAll(params: Parameters): Promise<SelectedObject[]> {\n const results = await this.#parameterizedQuery.execute(this.db, params);",
"score": 56.90040206844751
}
] | typescript | .instantiateNoReturns({}, transformedObj); |
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
| this.qb = qb.values(parameterizedValues) as QB; |
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
| src/queries/compiling-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns,\n UpdateReturn\n >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, returnColumns);\n const parameterizedValues = this.getParameterizedObject(columnsToUpdate);\n this.qb = qb.set(parameterizedValues) as QB;\n }",
"score": 65.15808485299206
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }",
"score": 44.41246310462738
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new SubsettingMappingInsertQuery(\n this.db,\n this.qb,\n columnsToInsert,",
"score": 38.60165296511754
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n> {\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToInsert: Readonly<\n (keyof Insertable<DB[TB]> & string)[]",
"score": 32.622942031491924
},
{
"filename": "src/queries/compiling-values-query.ts",
"retrieved_chunk": " }\n private getReturningQB(): QB {\n return this.returnColumns[0 as number] == '*'\n ? (this.qb!.returningAll() as QB)\n : (this.qb!.returning(\n this.returnColumns as Readonly<(keyof Selectable<DB[TB]> & string)[]>\n ) as QB);\n }\n private instantiate(\n compiledQuery: CompiledQuery<any>,",
"score": 30.58363793014746
}
] | typescript | this.qb = qb.values(parameterizedValues) as QB; |
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting an array of objects without transformation', () => {
it('inserts readonly objects', async () => {
const obj = {
name: 'John Doe' as const,
handle: 'johndoe' as const,
email: '[email protected]' as const,
} as const;
await userMapperReturningAll.insert().run(obj);
await userMapperReturningAll.insert().returnAll([obj]);
await userMapperReturningAll.insert().returnOne(obj);
});
it('inserts multiple via run() without returning columns', async () => {
const success = await userMapperReturningDefault.insert().run(USERS);
expect(success).toBe(true);
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
result.id;
// @ts-expect-error - can't access columns when returning nothing
result[0].id;
});
});
it('inserts multiple via returnAll() without returning columns', async () => {
const results = await userMapperReturningDefault.insert().returnAll(USERS);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple via returnOne() without returning columns', async () => {
const results = await userMapperReturningDefault
.insert()
.returnOne(USERS[0]);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(1);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple returning configured return columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
expect(Object.keys(insertReturns[i]).length).toEqual(1);
}
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
| const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id }); |
const post1 = Object.assign({}, POSTS[1], { userId: insertReturns[1].id });
const post2 = Object.assign({}, POSTS[2], { userId: insertReturns[2].id });
const updateReturns = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnAll([post0, post1, post2]);
expect(updateReturns.length).toEqual(3);
for (let i = 0; i < updateReturns.length; i++) {
expect(updateReturns[i].id).toBeGreaterThan(0);
expect(updateReturns[i].t).toEqual(POSTS[i].title);
expect(Object.keys(updateReturns[i]).length).toEqual(2);
}
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns[0].title;
// @ts-expect-error - check return types
updateReturns[0].userId;
});
});
it('inserts multiple returning no columns by default', async () => {
const insertReturns = await userMapperReturningDefault
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
});
it('inserts multiple explicitly returning no columns', async () => {
const insertReturns = await userMapperReturningNothing
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
insertReturns[0].id;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturns = await mapper.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
expect(insertReturns[0]).toEqual({
id: insertReturns[0].id,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturns[0].id);
((_: string) => {})(insertReturns[0].handle);
const newHandle = 'newHandle';
const updateReturns = await mapper
.update(1)
.returnAll({ handle: newHandle });
expect(updateReturns.length).toEqual(1);
expect(updateReturns[0]).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturns[0].name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturns[0].name;
// @ts-expect-error - check return types
updateReturns[0].id;
});
});
it('inserts multiple configured to return all columns', async () => {
const insertReturns = await userMapperReturningAll
.insert()
.returnAll(USERS);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
}
expect(insertReturns).toEqual(
USERS.map((user, i) =>
Object.assign({}, user, { id: insertReturns[i].id })
)
);
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(insertReturns[0].name);
});
ignore('detects inserting an array of objects type errors', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{ email: '[email protected]' }]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{ email: '[email protected]' }]);
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().returnAll([USERS[0]]))[0].handle;
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().run([USERS[0]]))[0].handle;
});
});
| src/tests/insert-array.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(0);\n });\n it('selects all rows with no filter', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting all\n const users = await userMapper.select().returnAll();\n expect(users.length).toEqual(USERS.length);\n for (let i = 0; i < USERS.length; i++) {\n expect(users[i].handle).toEqual(USERS[i].handle);\n }",
"score": 143.69139474232418
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const expectedUsers = USERS.map((user, i) => ({\n id: insertReturns[i].id,\n h: user.handle,\n }));\n expect(updateReturns).toEqual(expectedUsers);\n const readUsers = await userMapperReturningID.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (const user of readUsers) {\n expect(user.email).toEqual(updateValues.email);\n }",
"score": 130.8252256275683
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " expect(insertReturn1.id).toBeGreaterThan(0);\n expect(Object.keys(insertReturn1).length).toEqual(1);\n const readUser0 = await userMapperReturningAll\n .select('id', '=', insertReturn1.id)\n .returnOne();\n expect(readUser0?.email).toEqual(USERS[0].email);\n const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id });\n const insertReturn2 = await postTableMapperReturningIDAndTitleAsT\n .insert()\n .returnOne(post0);",
"score": 79.4606763415151
},
{
"filename": "src/lib/apply-query-filter.ts",
"retrieved_chunk": " if (typeof filter === 'object') {\n // Process a key tuple filter.\n if (Array.isArray(filter)) {\n keyColumns.forEach((column, i) => {\n qb = qb.where(db.dynamic.ref(column), '=', filter[i]) as QB;\n });\n return qb;\n }\n // Process a query expression filter. Check for expressions\n // first because they could potentially be plain objects.",
"score": 67.55031191224596
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " .returnAll(updateValues3);\n expect(updateReturns3.length).toEqual(3);\n expect(updateReturns3[0].h).toEqual(USERS[0].handle);\n expect(updateReturns3[1].h).toEqual(USERS[1].handle);\n expect(updateReturns3[2].h).toEqual(USERS[2].handle);\n const readUsers = await userMapperReturningID\n .select('name', '=', updateValues3.name)\n .returnAll();\n expect(readUsers.length).toEqual(3);\n ignore('check return types', () => {",
"score": 63.05148342548255
}
] | typescript | const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id }); |
import { Insertable, Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
import {
createUserMapperReturningAll,
createUserMapperReturningNothing,
} from './utils/test-mappers';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningAll = createUserMapperReturningAll(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
describe('compiled insertions', () => {
it('compiles a non-returning insert query without transformation', async () => {
const compilation = userMapperReturningNothing
.insert()
.columns(['name', 'handle'])
.compile();
// test run()
const success1 = await compilation.run(USERS[1]);
expect(success1).toBe(true);
// test returnOne()
const success2 = await compilation.returnOne(USERS[2]);
expect(success2).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].handle).toEqual(USERS[1].handle);
expect(readUsers[0].email).toEqual(null);
expect(readUsers[1].handle).toEqual(USERS[2].handle);
expect(readUsers[1].email).toEqual(null);
});
it('compiles a returning insert query without transformation', async () => {
const compilation = userMapperReturningAll
.insert()
.columns(['name', 'handle', 'email'])
.compile();
// test returnOne()
const insertReturn = await compilation.returnOne(USERS[0]);
expect(insertReturn).toEqual({ ...USERS[0], id: 1 });
// Ensure that the provided columns are accessible
((_: string) => {})(insertReturn!.name);
// test run()
const success1 = await compilation.run(USERS[1]);
expect(success1).toBe(true);
// test that non-specified columns are not inserted
const success2 = await compilation.run({ ...USERS[2], id: 100 });
expect(success2).toBe(true);
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
expect(readUsers[1].handle).toEqual(USERS[1].handle);
expect(readUsers[2].handle).toEqual(USERS[2].handle);
expect(readUsers[2].id).toEqual(3);
ignore('check compile-time types', () => {
compilation.returnOne({
name: 'xyz',
handle: 'pdq',
email: '[email protected]',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
});
// @ts-expect-error - only expected columns are returned
insertReturn!.notThere;
});
});
it('compiles an insert query with transformation', async () => {
expect.assertions(7);
| const columnSubset: (keyof Insertable<Users>)[] = [
'name',
'handle',
'email',
]; |
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: User, returns) =>
new User(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const user1: Readonly<User> = new User(
0,
'John',
'Doe',
'johndoe',
'[email protected]'
);
const user2: Readonly<User> = new User(
0,
'Sam',
'Gamgee',
'sg',
'[email protected]'
);
const user3 = new User(100, 'Sue', 'Rex', 'srex', '[email protected]');
const compilation = transformMapper
.insert()
.columns(columnSubset)
.compile();
// test returnOne()
const insertReturn = await compilation.returnOne(user1);
expect(insertReturn).toEqual(User.create(1, user1));
// Ensure that the provided columns are accessible
((_: string) => {})(insertReturn!.firstName);
// test run()
const success1 = await compilation.run(user2);
expect(success1).toBe(true);
// test that non-specified columns are not inserted
const success2 = await compilation.run(user3);
expect(success2).toBe(true);
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(1, user1),
User.create(2, user2),
User.create(3, user3),
]);
ignore('check compile-time types', () => {
// @ts-expect-error - only insertable objecs are allowed
compilation.returnOne(USERS[0]);
// @ts-expect-error - only insertable objecs are allowed
compilation.run(USERS[0]);
});
});
it('requires all indicated columns to be inserted', async () => {
const compilation = userMapperReturningAll
.insert()
.columns(['name', 'handle', 'email'])
.compile();
const insertValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne(insertValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({ ...insertValues, email: null });
expect(success).toBe(true);
});
});
| src/tests/insert-compile.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " notThere: 32,\n }\n );\n });\n });\n it('compiles an update query with transformation', async () => {\n expect.assertions(12);\n const columnSubset: (keyof Updateable<Users>)[] = ['name'];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['*'],",
"score": 42.91011856981865
},
{
"filename": "src/tests/setting-types.test.ts",
"retrieved_chunk": " 'users',\n [],\n ['*'],\n Selectable<Users>,\n Insertable<Users>,\n Updateable<Users>,\n bigint,\n ['name'],\n // @ts-expect-error - invalid return column configuration\n ['name', 'notThere']",
"score": 16.65102716470965
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 16.24298256053104
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " });\n // test with Updateable<Users>\n const newName = 'Suzanne Smith Something';\n await mapper.update({ id: insertReturn.id }).run({ name: newName });\n const readUser2 = await mapper.select(insertReturn.id).returnOne();\n expect(readUser2).toEqual({\n id: insertReturn.id,\n name: newName,\n email: userRow1.email,\n handle: userRow1.handle,",
"score": 16.20943293396072
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " const updateReturns4 = await compilation.returnCount({}, updateValues2);\n expect(updateReturns4).toEqual(1);\n });\n it('compiles a returning update query without transformation', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const compilation = userMapperReturningIDAndHandleAsH\n .update('id', '=', insertReturns[0].id)\n .columns(['name', 'email'])\n .compile();\n // test run()",
"score": 15.766630233716635
}
] | typescript | const columnSubset: (keyof Insertable<Users>)[] = [
'name',
'handle',
'email',
]; |
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapper: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['*']
>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapper = new TableMapper(db, 'posts', {
insertReturnColumns: ['*'],
}).withTransforms({
countTransform: (count) => Number(count),
});
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting a single object without transformation', () => {
it('inserts one returning no columns by default', async () => {
| const success = await userMapperReturningDefault.insert().run(USERS[0]); |
expect(success).toBe(true);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
});
it('inserts one explicitly returning no columns', async () => {
const insertReturn = await userMapperReturningNothing
.insert()
.returnOne(USERS[0]);
expect(insertReturn).toBe(undefined);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
ignore('type errors', () => {
// @ts-expect-error - check return type
insertReturn.id;
});
});
it('inserts one returning configured return columns', async () => {
const insertReturn1 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
expect(insertReturn1.id).toBeGreaterThan(0);
expect(Object.keys(insertReturn1).length).toEqual(1);
const readUser0 = await userMapperReturningAll
.select('id', '=', insertReturn1.id)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id });
const insertReturn2 = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnOne(post0);
expect(insertReturn2.id).toBeGreaterThan(0);
expect(insertReturn2.t).toEqual(POSTS[0].title);
expect(Object.keys(insertReturn2).length).toEqual(2);
const readPost0 = await postTableMapper
.select(({ and, cmpr }) =>
and([
cmpr('id', '=', insertReturn2.id),
cmpr('title', '=', insertReturn2.t),
])
)
.returnOne();
expect(readPost0?.likeCount).toEqual(post0.likeCount);
ignore('check return types', () => {
// @ts-expect-error - check return types
insertReturn1.title;
// @ts-expect-error - check return types
insertReturn1.userId;
// @ts-expect-error - check return types
insertReturn2.title;
// @ts-expect-error - check return types
insertReturn2.userId;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturn = await mapper.insert().returnOne(USERS[0]);
expect(insertReturn).toEqual({
id: 1,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturn.id);
((_: string) => {})(insertReturn.handle);
const newHandle = 'newHandle';
const updateReturn = await mapper
.update(1)
.returnOne({ handle: newHandle });
expect(updateReturn).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturn!.name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturn.name;
// @ts-expect-error - check return types
updateReturn!.id;
});
});
it('inserts one configured to return all columns', async () => {
const insertReturn = await userMapperReturningAll
.insert()
.returnOne(USERS[0]);
expect(insertReturn.id).toBeGreaterThan(0);
expect(insertReturn.email).toEqual(USERS[0].email);
const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });
expect(insertReturn).toEqual(expectedUser);
});
ignore('detects type errors inserting a single object', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({ email: '[email protected]' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: '[email protected]' });
// @ts-expect-error - only requested columns are returned
(await userMapperReturningID.insert().returnOne(USERS[0])).name;
// @ts-expect-error - only requested columns are returned
(await userMapperReturningDefault.insert().run(USERS[0])).name;
});
});
| src/tests/insert-single.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id', 'title as t'],\n }).withTransforms({\n countTransform: (count) => Number(count),\n });\n});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting an array of objects without transformation', () => {\n it('inserts readonly objects', async () => {\n const obj = {",
"score": 74.11747282909631
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " const count = await userMapper\n .delete({ name: USERS[0].name })\n .returnCount();\n expect(count).toEqual(0);\n const success = await userMapper.delete({ name: USERS[0].name }).run();\n expect(success).toEqual(false);\n });\n it('deletes rows without returning a count', async () => {\n const testMapper = new TableMapper(db, 'users').withTransforms({\n countTransform: (count) => Number(count),",
"score": 41.5335960253094
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " createUserMapperReturningIDAndHandleAsH(db);\n userMapperReturningAll = createUserMapperReturningAll(db);\n});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('general update', () => {\n it('updates nothing returning zero update count', async () => {\n const updateValues = { email: '[email protected]' };\n const success = await userMapperReturningAll\n .update({ id: 1 })",
"score": 38.311690149718295
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting with transformation', () => {\n it('transforms users for insertion without transforming return', async () => {\n const insertTransformMapper = createInsertTransformMapper(db);\n const insertReturn = await insertTransformMapper\n .insert()\n .returnOne(insertedUser1);\n const readUser1 = await insertTransformMapper",
"score": 38.05782069173602
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('deletes rows returning the deletion count inferred as a number', async () => {\n const testMapper = new TableMapper(db, 'users').withTransforms({\n countTransform: (count) => Number(count),\n });\n await testMapper.insert().run(USERS);\n const count = await testMapper\n .delete({ name: USERS[0].name })",
"score": 35.083688298050355
}
] | typescript | const success = await userMapperReturningDefault.insert().run(USERS[0]); |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
| insertTransform: (source: InsertedUser, columns) => { |
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " expect(updateReturn2).toEqual(1);\n // Ensure the returned value is accessible as a number\n ((_: number) => {})(updateReturn2!);\n });\n it(\"transforms update and update return, columns is ['*']\", async () => {\n expect.assertions(2);\n const updateAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({",
"score": 50.464781497826394
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " it('inserts multiple returning differently for inserts and updates', async () => {\n const mapper = createUserMapperReturningDifferently(db);\n const insertReturns = await mapper.insert().returnAll(USERS);\n expect(insertReturns.length).toEqual(3);\n expect(insertReturns[0]).toEqual({\n id: insertReturns[0].id,\n handle: USERS[0].handle,\n });\n // Ensure that returned objects can be accessed as expected.\n ((_: number) => {})(insertReturns[0].id);",
"score": 39.04008789561465
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(success).toBe(true);\n });\n it('provides insertTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = userMapperReturningID.withTransforms({\n insertTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },\n });",
"score": 32.13809098292539
},
{
"filename": "src/mappers/table-mapper-transforms.ts",
"retrieved_chunk": " InsertReturn\n> {\n /**\n * Transformation to apply to inserted objects before insertion. `source`\n * is the object provided for insertion. Only the columns in `columns` will\n * actually be inserted, with `[*]` indicating all columns.\n */\n insertTransform?: (\n source: InsertedObject,\n columns: Readonly<(keyof Insertable<DB[TB]>)[]> | ['*']",
"score": 31.266755256328068
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " const success = await subsetQuery.run({ ...updateValues, email: null });\n expect(success).toBe(true);\n });\n it('provides updateTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = new TableMapper(db, 'users').withTransforms({\n updateTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },",
"score": 30.438986257029633
}
] | typescript | insertTransform: (source: InsertedUser, columns) => { |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
| insertReturnTransform: (source, returns) => { |
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 51.05516969641476
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " it('transforms update return into primitive without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n updateReturnTransform: (_source, returns) => returns.id,\n });\n const insertReturn = await updateReturnTransformMapper\n .insert()",
"score": 43.50501613455164
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n });\n const insertReturns = await mapper",
"score": 30.700379051650096
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 30.150927529037574
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n insertReturnTransform: (source: User, returns) => ({\n id: returns.id,\n firstName: source.firstName,\n lastName: source.lastName,\n }),\n updateTransform: (source: User) => ({",
"score": 29.02574781647997
}
] | typescript | insertReturnTransform: (source, returns) => { |
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapper: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['*']
>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapper = new TableMapper(db, 'posts', {
insertReturnColumns: ['*'],
}).withTransforms({
countTransform: (count) => Number(count),
});
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting a single object without transformation', () => {
it('inserts one returning no columns by default', async () => {
const success = await userMapperReturningDefault.insert().run(USERS[0]);
expect(success).toBe(true);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
});
it('inserts one explicitly returning no columns', async () => {
const insertReturn = await userMapperReturningNothing
.insert()
.returnOne(USERS[0]);
expect(insertReturn).toBe(undefined);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
ignore('type errors', () => {
// @ts-expect-error - check return type
insertReturn.id;
});
});
it('inserts one returning configured return columns', async () => {
const insertReturn1 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
expect(insertReturn1.id).toBeGreaterThan(0);
expect(Object.keys(insertReturn1).length).toEqual(1);
const readUser0 = await userMapperReturningAll
.select('id', '=', insertReturn1.id)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
| const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id }); |
const insertReturn2 = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnOne(post0);
expect(insertReturn2.id).toBeGreaterThan(0);
expect(insertReturn2.t).toEqual(POSTS[0].title);
expect(Object.keys(insertReturn2).length).toEqual(2);
const readPost0 = await postTableMapper
.select(({ and, cmpr }) =>
and([
cmpr('id', '=', insertReturn2.id),
cmpr('title', '=', insertReturn2.t),
])
)
.returnOne();
expect(readPost0?.likeCount).toEqual(post0.likeCount);
ignore('check return types', () => {
// @ts-expect-error - check return types
insertReturn1.title;
// @ts-expect-error - check return types
insertReturn1.userId;
// @ts-expect-error - check return types
insertReturn2.title;
// @ts-expect-error - check return types
insertReturn2.userId;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturn = await mapper.insert().returnOne(USERS[0]);
expect(insertReturn).toEqual({
id: 1,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturn.id);
((_: string) => {})(insertReturn.handle);
const newHandle = 'newHandle';
const updateReturn = await mapper
.update(1)
.returnOne({ handle: newHandle });
expect(updateReturn).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturn!.name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturn.name;
// @ts-expect-error - check return types
updateReturn!.id;
});
});
it('inserts one configured to return all columns', async () => {
const insertReturn = await userMapperReturningAll
.insert()
.returnOne(USERS[0]);
expect(insertReturn.id).toBeGreaterThan(0);
expect(insertReturn.email).toEqual(USERS[0].email);
const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });
expect(insertReturn).toEqual(expectedUser);
});
ignore('detects type errors inserting a single object', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({ email: '[email protected]' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: '[email protected]' });
// @ts-expect-error - only requested columns are returned
(await userMapperReturningID.insert().returnOne(USERS[0])).name;
// @ts-expect-error - only requested columns are returned
(await userMapperReturningDefault.insert().run(USERS[0])).name;
});
});
| src/tests/insert-single.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " 0,\n USERS[0].name,\n USERS[0].handle,\n USERS[0].email!\n );\n const insertReturn1 = (await userMapper.insert().returnOne(insertedUser1))!;\n expect(insertReturn1).not.toBeNull();\n expect(insertReturn1.id).toBeGreaterThan(0);\n insertReturn1.name; // ensure 'name' is accessible\n // test getting a user by ID",
"score": 74.5666254975236
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(readUsers[i].handle).toEqual(USERS[i].handle);\n }\n const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id });\n const post1 = Object.assign({}, POSTS[1], { userId: insertReturns[1].id });\n const post2 = Object.assign({}, POSTS[2], { userId: insertReturns[2].id });\n const updateReturns = await postTableMapperReturningIDAndTitleAsT\n .insert()",
"score": 66.06439196033418
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " const selectedUser1 = await userMapper\n .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser1).toEqual({ ...insertedUser1, id: insertReturn1.id });\n // ensure 'id' is accessible\n expect(selectedUser1?.id).toEqual(insertReturn1.id);\n selectedUser1?.name; // ensure 'name' is accessible\n // test inserting a user with truthy id\n const insertedUser2 = new MappedUser(\n 10,",
"score": 57.174178232288405
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " // test deleting a user\n const deleted = await userMapper.delete({ id: insertReturn1.id }).run();\n expect(deleted).toEqual(true);\n const selectedUser5 = await userMapper\n .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser5).toBeNull();\n });\n it('inserts/updates/deletes with all custom transforms', async () => {\n class MappedUser {",
"score": 51.424676991178686
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser4).toEqual(updatingUser2);\n // test updating multiple users returning rows\n const updatingUser3 = new MappedUser(\n selectedUser1!.id,\n 'Everyone',\n selectedUser1!.handle,\n selectedUser1!.email\n );",
"score": 48.286676975112215
}
] | typescript | const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id }); |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: ( | source, results) => { |
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 34.24418130813228
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " ),\n ]);\n // Ensure the returned value is accessible as a ReturnedUser\n ((_: string) => {})(updateReturn[0].firstName);\n });\n it('transforms a union of updating object types', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser | Updateable<Users>) =>",
"score": 34.04395696528926
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 33.71126823802791
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " it('transforms update return into primitive without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n updateReturnTransform: (_source, returns) => returns.id,\n });\n const insertReturn = await updateReturnTransformMapper\n .insert()",
"score": 31.202021256326773
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " // Ensure that the returned value can be accessed as a row.\n ((_: string) => {})(updateReturn!.name);\n ((_: string | null) => {})(updateReturn!.email);\n });\n it('updates all rows when no filter is given', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { email: '[email protected]' };\n const updateReturns = await userMapperReturningIDAndHandleAsH\n .update()\n .returnAll(updateValues);",
"score": 29.8042428984222
}
] | typescript | source, results) => { |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
| insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
}); |
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " it('transforms update return into primitive without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n updateReturnTransform: (_source, returns) => returns.id,\n });\n const insertReturn = await updateReturnTransformMapper\n .insert()",
"score": 56.59076774916505
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " postTableMapper = new TableMapper(db, 'posts', {\n insertReturnColumns: ['*'],\n }).withTransforms({\n countTransform: (count) => Number(count),\n });\n postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {\n insertReturnColumns: ['id', 'title as t'],\n }).withTransforms({\n countTransform: (count) => Number(count),\n });",
"score": 44.2725131363498
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 42.760084311222386
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " it('accepts readonly transforms', () => {\n const transforms = {\n countTransform: (count: bigint) => count,\n } as const;\n new TableMapper(db, 'users', {}).withTransforms(transforms);\n });\n});",
"score": 36.180624471150566
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id', 'title as t'],\n }).withTransforms({\n countTransform: (count) => Number(count),\n });\n});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting an array of objects without transformation', () => {\n it('inserts readonly objects', async () => {\n const obj = {",
"score": 36.06513309289684
}
] | typescript | insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
}); |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: | InsertedUser, columns) => { |
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " expect(updateReturn2).toEqual(1);\n // Ensure the returned value is accessible as a number\n ((_: number) => {})(updateReturn2!);\n });\n it(\"transforms update and update return, columns is ['*']\", async () => {\n expect.assertions(2);\n const updateAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({",
"score": 46.4284622901419
},
{
"filename": "src/mappers/table-mapper-transforms.ts",
"retrieved_chunk": " InsertReturn\n> {\n /**\n * Transformation to apply to inserted objects before insertion. `source`\n * is the object provided for insertion. Only the columns in `columns` will\n * actually be inserted, with `[*]` indicating all columns.\n */\n insertTransform?: (\n source: InsertedObject,\n columns: Readonly<(keyof Insertable<DB[TB]>)[]> | ['*']",
"score": 31.266755256328068
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " it('inserts multiple returning differently for inserts and updates', async () => {\n const mapper = createUserMapperReturningDifferently(db);\n const insertReturns = await mapper.insert().returnAll(USERS);\n expect(insertReturns.length).toEqual(3);\n expect(insertReturns[0]).toEqual({\n id: insertReturns[0].id,\n handle: USERS[0].handle,\n });\n // Ensure that returned objects can be accessed as expected.\n ((_: number) => {})(insertReturns[0].id);",
"score": 29.974063903781328
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(success).toBe(true);\n });\n it('provides insertTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = userMapperReturningID.withTransforms({\n insertTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },\n });",
"score": 29.69411290223298
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " ),\n ]);\n // Ensure the returned value is accessible as a ReturnedUser\n ((_: string) => {})(updateReturn[0].firstName);\n });\n it('transforms a union of updating object types', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser | Updateable<Users>) =>",
"score": 29.080088720485005
}
] | typescript | InsertedUser, columns) => { |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
| return SelectedUser.create(results.id, { |
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 46.28745794180627
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " 'handle',\n 'email',\n ];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },",
"score": 39.44982185978568
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 36.77230222025055
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " updateReturnColumns: ['*'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,",
"score": 35.3179282882399
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " it('transforms update return into primitive without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n updateReturnTransform: (_source, returns) => returns.id,\n });\n const insertReturn = await updateReturnTransformMapper\n .insert()",
"score": 33.57526368169366
}
] | typescript | return SelectedUser.create(results.id, { |
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely, sql } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createUserMapperReturningID } from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('selecting all returns', () => {
it('accepts readonly filters', async () => {
const filter1 = { name: 'Not There' as const } as const;
await userMapper.select(filter1).returnAll();
await userMapper.select(filter1).returnOne();
const filter2 = { name: ['name1', 'name2'] as const } as const;
await userMapper.select(filter2).returnAll();
await userMapper.select(filter2).returnOne();
});
it('selects nothing when nothing matches filter', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper.select({ name: 'Not There' }).returnAll();
expect(users.length).toEqual(0);
});
it('selects all rows with no filter', async () => {
await userMapper.insert().run(USERS);
// Test selecting all
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(USERS.length);
for (let i = 0; i < USERS.length; i++) {
expect(users[i].handle).toEqual(USERS[i].handle);
}
});
it('selects via key column values', async () => {
await userMapper.insert().run(USERS);
// Test selecting via key value
const users1 = await userMapper.select(2).returnAll();
expect(users1.length).toEqual(1);
expect(users1[0].handle).toEqual(USERS[1].handle);
// Test selecting via key tuple
const users2 = await userMapper.select([2]).returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('selects with a matching field filter', async () => {
await userMapper.insert().run(USERS);
let users = await userMapper
.select({
name: USERS[0].name,
})
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
users = await userMapper
.select({
name: USERS[0].name,
handle: USERS[2].handle,
})
.returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[2].handle);
users = await userMapper
.select({
handle: [USERS[1].handle, USERS[2].handle],
})
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[1].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
});
it('selects with a binary operation filter', async () => {
await userMapper.insert().run(USERS);
// Test selecting by condition (with results)
let users = await userMapper.select('name', '=', USERS[0].name).returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Test selecting by condition (no results)
users = await userMapper.select('name', '=', 'nonexistent').returnAll();
expect(users.length).toEqual(0);
});
it('selects with a binary operation filter using .ref()', async () => {
await userMapper.insert().run(USERS);
// Test selecting by condition (with results)
let users = await userMapper
.select(userMapper.ref('name'), '=', USERS[0].name)
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Test selecting by condition (no results)
users = await userMapper
.select(userMapper.ref('email'), '=', 'nonexistent')
.returnAll();
expect(users.length).toEqual(0);
});
it('selects with a query expression filter', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select(sql`name != ${USERS[0].name}`)
.returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('selects many returning selected columns and aliases', async () => {
const ids = await userMapper.insert().returnAll(USERS);
const mapper = new TableMapper(db, 'users', {
selectedColumns: ['id', 'handle as h'],
});
// Should allow access to aliased columns
(await mapper.select().returnAll())[0].h;
const users = await mapper.select({ name: USERS[0].name }).returnAll();
expect(users).toEqual([
{
id: ids[0].id,
h: USERS[0].handle,
},
{
id: ids[2].id,
h: USERS[2].handle,
},
]);
ignore('inaccessible types are not allowed', async () => {
// @ts-expect-error - aliases are not allowed in filter expressions
mapper.select({ h: USERS[0].handle });
// @ts-expect-error - unselected columns are not allowed
(await mapper.select().returnAll())[0].name;
});
});
ignore(
'detects selecting returnAll() simple filter type errors',
async () => {
// @ts-expect-error - only table columns are accessible unfiltered
(await userMapper.select().returnAll())[0].notThere;
// @ts-expect-error - only table columns are accessible unfiltered
(await userMapper.select({}).returnAll())[0].notThere;
// @ts-expect-error - only table columns are accessible w/ object filter
// prettier-ignore
(await userMapper.select({ name: "Sue" }).returnAll())[0].notThere;
// @ts-expect-error - only table columns are accessible w/ op filter
// prettier-ignore
(await userMapper.select("name", "=", "Sue").returnAll())[0].notThere;
// prettier-ignore
(
await userMapper
| .select((qb) => qb)
.returnAll()
// @ts-expect-error - only table columns are accessible w/ QB filter
)[0].notThere; |
// prettier-ignore
(
await userMapper
.select(sql`name = 'Sue'`)
.returnAll()
// @ts-expect-error - only table columns are accessible w/ expr filter
)[0].notThere;
}
);
});
| src/tests/select-all.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/select-one.test.ts",
"retrieved_chunk": " // prettier-ignore\n (await userMapper.select(\"name\", \"=\", \"Sue\").returnOne()).notThere;\n // prettier-ignore\n (\n await userMapper\n .select((qb) => qb)\n .returnOne()\n // @ts-expect-error - only table columns are accessible w/ QB filter\n )!.notThere;\n // prettier-ignore",
"score": 110.56985190872149
},
{
"filename": "src/tests/select-one.test.ts",
"retrieved_chunk": " // @ts-expect-error - unselected columns are not allowed\n (await mapper.select().returnAll())[0].name;\n });\n });\n ignore('detects selecting returnOne() type errors', async () => {\n // @ts-expect-error - only table columns are accessible unfiltered\n (await userMapper.select({}).returnOne()).notThere;\n // @ts-expect-error - only table columns are accessible w/ object filter\n (await userMapper.select({ name: 'Sue' }).returnOne()).notThere;\n // @ts-expect-error - only table columns are accessible w/ op filter",
"score": 96.41895760018309
},
{
"filename": "src/tests/select-one.test.ts",
"retrieved_chunk": " (\n await userMapper\n .select(sql`name = 'Sue'`)\n .returnOne()\n // @ts-expect-error - only table columns are accessible w/ expr filter\n )!.notThere;\n });\n});",
"score": 83.87170886449529
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;\n userMapperReturningID.update({ id: 32 }).returnOne(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }\n );\n // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;",
"score": 71.25279779453602
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " ignore('detects deletion type errors', async () => {\n // @ts-expect-error - table must have all filter fields\n userMapper.delete({ notThere: 'xyz' });\n // @ts-expect-error - table must have all filter fields\n userMapper.delete('notThere', '=', 'foo');\n userMapper.delete(({ or, cmpr }) =>\n // @ts-expect-error - only table columns are accessible via anyOf()\n or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])\n );\n userMapper.delete(({ or, cmpr }) =>",
"score": 62.33690745590872
}
] | typescript | .select((qb) => qb)
.returnAll()
// @ts-expect-error - only table columns are accessible w/ QB filter
)[0].notThere; |
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general selection', () => {
it('compiles an unparameterized select query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.select({ name: USERS[0].name }).compile();
const users = await compilation.returnAll({});
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
const user = await compilation.returnOne({});
expect(user?.handle).toEqual(USERS[0].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
ignore('compilation type errors', () => {
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
});
});
it('parameterizes and compiles a select query', async () => {
await userMapper.insert().run(USERS);
const parameterization = userMapper.parameterize<{ name: string }>(
| ({ mapper, param }) => mapper.select({ name: param('name') })
); |
// test returnAll() returning multiple
const users = await parameterization.returnAll({ name: USERS[0].name });
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
// test returnAll() returning none
const users2 = await parameterization.returnAll({ name: 'not there' });
expect(users2.length).toEqual(0);
// test returnOne() returning one
const user = await parameterization.returnOne({ name: USERS[1].name });
expect(user?.handle).toEqual(USERS[1].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
// test returnOne() returning none
const user2 = await parameterization.returnOne({ name: 'not there' });
expect(user2).toBeNull();
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ notThere: 'foo' });
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ name: 123 });
});
});
it('modifies the underlying query builder', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[2].handle);
expect(users[1].handle).toEqual(USERS[0].handle);
const user = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('does not modify the underlying selected columns', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnAll();
expect(users).toEqual([
{ ...USERS[2], id: 3 },
{ ...USERS[1], id: 2 },
{ ...USERS[0], id: 1 },
]);
// Ensure that columns can be addressed by name.
((_: number) => {})(users[0].id);
((_: string) => {})(users[0].handle);
((_: string) => {})(users[0].name);
((_: string) => {})(users[0].email!);
const user = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnOne();
expect(user).toEqual({ ...USERS[2], id: 3 });
// Ensure that columns can be addressed by name.
((_: number) => {})(user!.id);
((_: string) => {})(user!.handle);
((_: string) => {})(user!.name);
((_: string) => {})(user!.email!);
ignore('detects modify() type errors', async () => {
// @ts-expect-error - cannot access invalid columns
users[0].notThere;
// @ts-expect-error - cannot access invalid columns
user!.notThere;
});
});
it('selects via a multi-column key tuple (definition order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id', 'name'],
});
await mapper.insert().run(USERS);
const users = await mapper.select([3, 'Sue']).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
it('selects via a multi-column key tuple (different order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['name', 'id'],
});
await mapper.insert().run(USERS);
const users = await mapper.select(['Sue', 3]).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
ignore('detects select(filter) type errors', async () => {
// @ts-expect-error - doesn't allow only two arguments
userMapper.select('name', '=');
// @ts-expect-error - object filter fields must be valid
userMapper.select({ notThere: 'xyz' });
userMapper.select(({ or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')])
);
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('notThere', '=', 'foo');
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('users.notThere', '=', 'foo');
// @ts-expect-error - ID filter must have correct type
userMapper.select('str');
// @ts-expect-error - ID filter must have correct type
userMapper.select(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select([1]);
});
});
| src/tests/select-general.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(count3).toEqual(1);\n const users2 = await userMapper.select().returnAll();\n expect(users2.length).toEqual(0);\n ignore('parameterization type errors', () => {\n // @ts-expect-error - errors on invalid parameter names\n parameterization.run({ notThere: 'foo' });\n userMapper.parameterize<{ name: string }>(\n // @ts-expect-error - errors on invalid parameter name\n ({ mapper, param }) => mapper.select({ name: param('notThere') })\n );",
"score": 68.17458165892626
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " userMapper.parameterize<{ name: number }>(\n // @ts-expect-error - errors on invalid parameter type\n ({ mapper, param }) => mapper.select({ name: param('name') })\n );\n // @ts-expect-error - errors on invalid parameter value name\n parameterization.run({ notThere: 'foo' });\n // @ts-expect-error - errors on invalid parameter value type\n parameterization.run({ targetName: 123 });\n });\n });",
"score": 62.98425912830533
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " });\n it('parameterizes and compiles a delete query', async () => {\n const parameterization = userMapper.parameterize<{ targetName: string }>(\n ({ mapper, param }) => mapper.delete({ name: param('targetName') })\n );\n const count1 = await parameterization.returnCount({\n targetName: USERS[0].name,\n });\n expect(count1).toEqual(0);\n await userMapper.insert().run(USERS);",
"score": 57.456270873246446
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter name\n mapper.update({ id: param('handle') }).columns(['name'])\n );\n transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter type\n mapper.update({ id: param('id') }).columns(['name'])\n );\n // @ts-expect-error - errors on invalid parameter value name\n parameterization.returnOne({ handle: 'foo' }, user1);",
"score": 49.88604449753459
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " ({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter name\n mapper.update({ id: param('handle') }).columns(['name'])\n );\n userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(\n ({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter type\n mapper.update({ id: param('id') }).columns(['name'])\n );\n // @ts-expect-error - errors on invalid parameter value name",
"score": 48.36643384750905
}
] | typescript | ({ mapper, param }) => mapper.select({ name: param('name') })
); |
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { User } from './utils/test-types';
import { ignore } from './utils/test-utils';
import { createInsertTransformMapper } from './utils/test-mappers';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper transform type checks', () => {
ignore('detects invalid select transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid select transform
selectTransform: (user: User) => user,
});
});
ignore('detects invalid insert transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid insert transform
insertTransform: (user: User) => user,
});
});
ignore('detects invalid update transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid update transform
updateTransform: (_user) => ({ noId: 1 }),
});
});
ignore('detects invalid update return transform return', async () => {
const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });
mapper.withTransforms({
selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', '[email protected]'),
updateTransform: (user: User) => ({
id: user.id,
name: `${user.firstName} ${user.lastName}`,
handle: user.handle,
email: user.email,
}),
| updateReturnTransform: (_user, returns) => returns,
}); |
(await mapper
.update({ id: 1 })
// @ts-expect-error - ensure that return type is User
.returnOne(new User(1, 'John', 'Doe', 'jdoe', '[email protected]')))!.name;
});
ignore('detects insertion transformation type errors', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(selectedUser1);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(selectedUser1);
});
it('accepts readonly transforms', () => {
const transforms = {
countTransform: (count: bigint) => count,
} as const;
new TableMapper(db, 'users', {}).withTransforms(transforms);
});
});
| src/tests/transform-types.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " name: `${user.firstName} ${user.lastName}`,\n handle: user.handle + '2',\n email: user.email,\n };\n },\n updateReturnTransform: (user, returns) => {\n return new MappedUser(\n returns.id,\n user.firstName,\n user.lastName,",
"score": 67.90692718551732
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (user: MappedUser) => ({\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,\n email: user.email,\n }),\n insertReturnTransform: (user, returns) =>\n new MappedUser(\n returns.id,",
"score": 65.22059517814372
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " user.firstName,\n user.lastName,\n user.handle,\n user.email\n ),\n updateTransform: (user: MappedUser) => {\n if (!(user instanceof MappedUser)) {\n return user;\n }\n return {",
"score": 55.96815237521941
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " user.handle,\n user.email\n );\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new MappedUser(\n row.id,\n names[0],\n names[1],",
"score": 47.36789889142768
},
{
"filename": "src/tests/select-one.test.ts",
"retrieved_chunk": " user = await userMapper\n .select({\n name: USERS[0].name,\n handle: USERS[2].handle,\n })\n .returnOne();\n expect(user?.handle).toEqual(USERS[2].handle);\n user = await userMapper\n .select({\n id: [1, 2],",
"score": 40.620961951899965
}
] | typescript | updateReturnTransform: (_user, returns) => returns,
}); |
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general selection', () => {
it('compiles an unparameterized select query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.select({ name: USERS[0].name }).compile();
const users = await compilation.returnAll({});
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
const user = await compilation.returnOne({});
expect(user?.handle).toEqual(USERS[0].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
ignore('compilation type errors', () => {
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
});
});
it('parameterizes and compiles a select query', async () => {
await userMapper.insert().run(USERS);
const parameterization = userMapper.parameterize<{ name: string }>(
({ mapper, | param }) => mapper.select({ name: param('name') })
); |
// test returnAll() returning multiple
const users = await parameterization.returnAll({ name: USERS[0].name });
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
// test returnAll() returning none
const users2 = await parameterization.returnAll({ name: 'not there' });
expect(users2.length).toEqual(0);
// test returnOne() returning one
const user = await parameterization.returnOne({ name: USERS[1].name });
expect(user?.handle).toEqual(USERS[1].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
// test returnOne() returning none
const user2 = await parameterization.returnOne({ name: 'not there' });
expect(user2).toBeNull();
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ notThere: 'foo' });
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ name: 123 });
});
});
it('modifies the underlying query builder', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[2].handle);
expect(users[1].handle).toEqual(USERS[0].handle);
const user = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('does not modify the underlying selected columns', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnAll();
expect(users).toEqual([
{ ...USERS[2], id: 3 },
{ ...USERS[1], id: 2 },
{ ...USERS[0], id: 1 },
]);
// Ensure that columns can be addressed by name.
((_: number) => {})(users[0].id);
((_: string) => {})(users[0].handle);
((_: string) => {})(users[0].name);
((_: string) => {})(users[0].email!);
const user = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnOne();
expect(user).toEqual({ ...USERS[2], id: 3 });
// Ensure that columns can be addressed by name.
((_: number) => {})(user!.id);
((_: string) => {})(user!.handle);
((_: string) => {})(user!.name);
((_: string) => {})(user!.email!);
ignore('detects modify() type errors', async () => {
// @ts-expect-error - cannot access invalid columns
users[0].notThere;
// @ts-expect-error - cannot access invalid columns
user!.notThere;
});
});
it('selects via a multi-column key tuple (definition order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id', 'name'],
});
await mapper.insert().run(USERS);
const users = await mapper.select([3, 'Sue']).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
it('selects via a multi-column key tuple (different order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['name', 'id'],
});
await mapper.insert().run(USERS);
const users = await mapper.select(['Sue', 3]).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
ignore('detects select(filter) type errors', async () => {
// @ts-expect-error - doesn't allow only two arguments
userMapper.select('name', '=');
// @ts-expect-error - object filter fields must be valid
userMapper.select({ notThere: 'xyz' });
userMapper.select(({ or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')])
);
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('notThere', '=', 'foo');
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('users.notThere', '=', 'foo');
// @ts-expect-error - ID filter must have correct type
userMapper.select('str');
// @ts-expect-error - ID filter must have correct type
userMapper.select(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select([1]);
});
});
| src/tests/select-general.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(count3).toEqual(1);\n const users2 = await userMapper.select().returnAll();\n expect(users2.length).toEqual(0);\n ignore('parameterization type errors', () => {\n // @ts-expect-error - errors on invalid parameter names\n parameterization.run({ notThere: 'foo' });\n userMapper.parameterize<{ name: string }>(\n // @ts-expect-error - errors on invalid parameter name\n ({ mapper, param }) => mapper.select({ name: param('notThere') })\n );",
"score": 63.33949225735986
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " userMapper.parameterize<{ name: number }>(\n // @ts-expect-error - errors on invalid parameter type\n ({ mapper, param }) => mapper.select({ name: param('name') })\n );\n // @ts-expect-error - errors on invalid parameter value name\n parameterization.run({ notThere: 'foo' });\n // @ts-expect-error - errors on invalid parameter value type\n parameterization.run({ targetName: 123 });\n });\n });",
"score": 60.11777756039677
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " });\n it('parameterizes and compiles a delete query', async () => {\n const parameterization = userMapper.parameterize<{ targetName: string }>(\n ({ mapper, param }) => mapper.delete({ name: param('targetName') })\n );\n const count1 = await parameterization.returnCount({\n targetName: USERS[0].name,\n });\n expect(count1).toEqual(0);\n await userMapper.insert().run(USERS);",
"score": 56.18021017613493
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter name\n mapper.update({ id: param('handle') }).columns(['name'])\n );\n transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter type\n mapper.update({ id: param('id') }).columns(['name'])\n );\n // @ts-expect-error - errors on invalid parameter value name\n parameterization.returnOne({ handle: 'foo' }, user1);",
"score": 49.88604449753459
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " ({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter name\n mapper.update({ id: param('handle') }).columns(['name'])\n );\n userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(\n ({ mapper, param }) =>\n // @ts-expect-error - errors on invalid parameter type\n mapper.update({ id: param('id') }).columns(['name'])\n );\n // @ts-expect-error - errors on invalid parameter value name",
"score": 48.36643384750905
}
] | typescript | param }) => mapper.select({ name: param('name') })
); |
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely, sql } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createUserMapperReturningID } from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('selecting one return', () => {
it('selects the first row with no filter', async () => {
await userMapper.insert().run(USERS);
let user = await userMapper.select().returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
user = await userMapper.select({}).returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
});
it('selects the first row with a matching field filter', async () => {
await userMapper.insert().run(USERS);
let user = await userMapper.select({ name: USERS[0].name }).returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
user = await userMapper
.select({
name: USERS[0].name,
handle: USERS[2].handle,
})
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
user = await userMapper
.select({
id: [1, 2],
handle: [USERS[1].handle, USERS[2].handle],
})
.returnOne();
expect(user?.handle).toEqual(USERS[1].handle);
});
it('selects the first row with a binary operation filter', async () => {
await userMapper.insert().run(USERS);
// Test selecting by condition (with result)
let user = await userMapper.select('name', '=', USERS[0].name).returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
// Test selecting by condition (no result)
user = await userMapper.select('name', '=', 'nonexistent').returnOne();
expect(user).toBeNull();
});
it('selects the first row with a query expression filter', async () => {
await userMapper.insert().run(USERS);
const user = await userMapper
.select(sql`name != ${USERS[0].name}`)
.returnOne();
expect(user?.handle).toEqual(USERS[1].handle);
});
it('selects the first row with a compound filter', async () => {
const userIDs = await userMapper.insert().returnAll(USERS);
const user = await userMapper
.select(({ and, cmpr }) =>
and([cmpr('name', '=', USERS[0].name), cmpr('id', '>', userIDs[0].id)])
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('selects one returning selected columns and aliases', async () => {
const ids = await userMapper.insert().returnAll(USERS);
const mapper = new TableMapper(db, 'users', {
selectedColumns: ['id', 'handle as h'],
});
// Should allow access to aliased columns
(await mapper.select().returnOne())!.h;
const user = await mapper.select({ handle: USERS[0].handle }).returnOne();
expect(user).toEqual({ id: ids[0].id, h: USERS[0].handle });
ignore('inaccessible types are not allowed', async () => {
// @ts-expect-error - unselected columns are not allowed
(await mapper.select().returnAll())[0].name;
});
});
ignore('detects selecting returnOne() type errors', async () => {
// @ts-expect-error - only table columns are accessible unfiltered
(await userMapper.select({}).returnOne()).notThere;
// @ts-expect-error - only table columns are accessible w/ object filter
(await userMapper.select({ name: 'Sue' }).returnOne()).notThere;
// @ts-expect-error - only table columns are accessible w/ op filter
// prettier-ignore
(await userMapper.select("name", "=", "Sue").returnOne()).notThere;
// prettier-ignore
(
await userMapper
| .select((qb) => qb)
.returnOne()
// @ts-expect-error - only table columns are accessible w/ QB filter
)!.notThere; |
// prettier-ignore
(
await userMapper
.select(sql`name = 'Sue'`)
.returnOne()
// @ts-expect-error - only table columns are accessible w/ expr filter
)!.notThere;
});
});
| src/tests/select-one.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " async () => {\n // @ts-expect-error - only table columns are accessible unfiltered\n (await userMapper.select().returnAll())[0].notThere;\n // @ts-expect-error - only table columns are accessible unfiltered\n (await userMapper.select({}).returnAll())[0].notThere;\n // @ts-expect-error - only table columns are accessible w/ object filter\n // prettier-ignore\n (await userMapper.select({ name: \"Sue\" }).returnAll())[0].notThere;\n // @ts-expect-error - only table columns are accessible w/ op filter\n // prettier-ignore",
"score": 109.28553739019091
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " (await userMapper.select(\"name\", \"=\", \"Sue\").returnAll())[0].notThere;\n // prettier-ignore\n (\n await userMapper\n .select((qb) => qb)\n .returnAll()\n // @ts-expect-error - only table columns are accessible w/ QB filter\n )[0].notThere;\n // prettier-ignore\n (",
"score": 106.33215875535704
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " await userMapper\n .select(sql`name = 'Sue'`)\n .returnAll()\n // @ts-expect-error - only table columns are accessible w/ expr filter\n )[0].notThere;\n }\n );\n});",
"score": 82.22928112820968
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;\n userMapperReturningID.update({ id: 32 }).returnOne(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }\n );\n // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;",
"score": 69.18414560807203
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " ignore('detects deletion type errors', async () => {\n // @ts-expect-error - table must have all filter fields\n userMapper.delete({ notThere: 'xyz' });\n // @ts-expect-error - table must have all filter fields\n userMapper.delete('notThere', '=', 'foo');\n userMapper.delete(({ or, cmpr }) =>\n // @ts-expect-error - only table columns are accessible via anyOf()\n or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])\n );\n userMapper.delete(({ or, cmpr }) =>",
"score": 62.145579412036376
}
] | typescript | .select((qb) => qb)
.returnOne()
// @ts-expect-error - only table columns are accessible w/ QB filter
)!.notThere; |
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createUserMapperReturningID } from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
beforeAll(async () => {
db = await createDB();
userMapperReturningID = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating specific columns', () => {
it('subsets updating columns, excluding ID', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { id: 100, name: 'Sue Rex', email: '[email protected]' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['name'] as const); // allows readonly array
const updateReturns = await subsetQuery.returnAll(updateValues);
expect(updateReturns).toEqual([{ id: insertReturns[0].id }]);
const readUsers = await userMapperReturningID
.select('id', '=', insertReturns[0].id)
.returnOne();
expect(readUsers).toEqual({
id: insertReturns[0].id,
name: 'Sue Rex',
email: USERS[0].email,
handle: USERS[0].handle,
});
});
it('subsets updating columns, including ID', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { id: 100, name: 'Sue Rex', email: '[email protected]' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['id', 'name', 'email']);
const updateReturns = await subsetQuery.returnAll(updateValues);
expect(updateReturns).toEqual([{ id: 100 }]);
const readUsers = await userMapperReturningID
.select('id', '=', 100)
.returnOne();
expect(readUsers).toEqual({
id: 100,
name: 'Sue Rex',
email: '[email protected]',
handle: USERS[0].handle,
});
});
it('requires all subsetted columns to be updated', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { name: 'Sue Rex' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email']);
expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await subsetQuery.run({ ...updateValues, email: null });
expect(success).toBe(true);
});
it('provides updateTransform with column subset', async () => {
expect.assertions(1);
| const mapper = new TableMapper(db, 'users').withTransforms({ |
updateTransform: (source, columns) => {
expect(columns).toEqual(['name', 'handle']);
return source;
},
});
await mapper.update().columns(['name', 'handle']).run({
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
});
});
| src/tests/update-columns.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(\n `column 'email' missing`\n );\n const success = await compilation.run({}, { ...updateValues, email: null });\n expect(success).toBe(true);\n });\n});",
"score": 74.41082841476889
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " });\n it('requires all subsetted columns to be inserted', async () => {\n const subsetQuery = userMapperReturningID\n .insert()\n .columns(['name', 'handle', 'email']);\n const insertValues = { name: 'John Doe', handle: 'johndoe' };\n expect(() => subsetQuery.returnOne(insertValues)).rejects.toThrow(\n `column 'email' missing`\n );\n const success = await subsetQuery.run({ ...insertValues, email: null });",
"score": 62.54191203869547
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(success).toBe(true);\n });\n it('provides insertTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = userMapperReturningID.withTransforms({\n insertTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },\n });",
"score": 57.90700236998397
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " const success = await compilation.run({ ...insertValues, email: null });\n expect(success).toBe(true);\n });\n});",
"score": 39.76861178460549
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " });\n it('requires all indicated columns to be inserted', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n const insertValues = { name: 'John Doe', handle: 'johndoe' };\n expect(() => compilation.returnOne(insertValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 36.58083995564435
}
] | typescript | const mapper = new TableMapper(db, 'users').withTransforms({ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.