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": 0.8882730603218079
},
{
"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": 0.8195081353187561
},
{
"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": 0.8106625080108643
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'charge' -> 'background' -> 'content'\n kind: 'leaveChargeMode';\n request: {\n senderTabId: number;\n };\n response: void;\n };",
"score": 0.808469295501709
},
{
"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": 0.8055186867713928
}
] |
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": 0.8113157749176025
},
{
"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": 0.7920575737953186
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " neutral,\n },\n },\n };\n chrome.runtime.sendMessage(req);\n };\n const reportListener = (ev: HIDInputReportEvent) => {\n const value = getStrain(ev);\n if (value) {\n sendStrain(value);",
"score": 0.7914501428604126
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " chrome.runtime.onMessage.addListener(listener);\n },\n removeEventListener: (listener) => {\n chrome.runtime.onMessage.removeListener(listener);\n },\n },\n );\n // Stop sending strain signals.\n joycon.removeEventListener('inputreport', reportListener);\n return {",
"score": 0.7814720869064331
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": "import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';\nimport { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';\ninjectResourceScript('js/nip07-provider.js');\n// 'nip07-provider' -> ...\nwindow.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');\n if (!shouldBeHandled) {\n return;\n }\n if (next === 'background') {",
"score": 0.7638986110687256
}
] |
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/@types/common/index.d.ts",
"retrieved_chunk": "}\ninterface _CrxRpcMessageBase {\n ext: ExtName;\n messageId: number;\n}\ntype CrxMessageOrigin = 'nip07-provider' | 'content' | 'background' | 'charge';\ntype CrxRpc =\n | {\n // possible paths:\n // - 'nip07-provider' -> 'content' -> 'background'",
"score": 0.8668896555900574
},
{
"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": 0.860658586025238
},
{
"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": 0.8556503057479858
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " kind: 'enterChargeMode';\n request: {};\n response: boolean;\n }\n | {\n // possible paths:\n // - 'content' -> 'background'\n kind: 'openChargeWindow';\n request: {};\n response: number; // tabId",
"score": 0.8515751957893372
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " }\n },\n};\nconst ext: ExtName = 'nostronger';\nfunction rpc<T extends CrxRpcRequestPayload>(\n req: T,\n path: CrxMessageOrigin[],\n timeout?: number,\n): Promise<CrxRpcResponse<T>> {\n return new Promise((resolve, reject) => {",
"score": 0.8427209258079529
}
] |
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": 0.8482767343521118
},
{
"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": 0.8240189552307129
},
{
"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": 0.8226242065429688
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " device.sendReport(\n 0x01,\n new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),\n );\n },\n // timeout: 5000,\n },\n );\n}\nexport async function getNextStrain(joycon: HIDDevice) {",
"score": 0.8212614059448242
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " await rpc(\n {\n kind: 'enterChargeMode',\n request: {},\n },\n ['content'],\n );\n signPower = await rpc(\n {\n kind: 'getSignPower',",
"score": 0.8197361826896667
}
] |
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/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": 0.829292356967926
},
{
"filename": "src/errors.ts",
"retrieved_chunk": " constructor(opts?: { message?: string; cause?: Error }) {\n super(opts?.message);\n this.cause = opts?.cause;\n }\n}\nexport class ApiError extends AppError {\n type: string;\n param: string;\n code: string;\n constructor(data: {",
"score": 0.8006801605224609
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": " }\n const stream = openAIQuery(model, formattedPrompt, config);\n const chunks = [];\n for await (const chunk of stream) {\n chunks.push(chunk);\n yield chunk;\n }\n if (cache) {\n const response = chunks.join(\"\");\n await cache.set(cacheKey, response);",
"score": 0.8006250858306885
},
{
"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": 0.7970672845840454
},
{
"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": 0.7856347560882568
}
] |
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": 0.8668875694274902
},
{
"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": 0.8447960615158081
},
{
"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": 0.8348185420036316
},
{
"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": 0.8250904679298401
},
{
"filename": "src/prompts/ask.ts",
"retrieved_chunk": "import { ParsedResponse, PromptConfiguration } from \"../types.js\";\nconst promptConfiguration: PromptConfiguration = {\n description: \"Just passes through the input directly to ChatGPT.\",\n createPrompt(input: string) {\n return input;\n },\n parseResponse(response: string, _input: string): ParsedResponse {\n return { message: response };\n },\n};",
"score": 0.8141838312149048
}
] |
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": "}\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": 0.8469076156616211
},
{
"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": 0.8417678475379944
},
{
"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": 0.835041880607605
},
{
"filename": "src/prompts/eli5.ts",
"retrieved_chunk": "export default promptConfiguration;",
"score": 0.8323736786842346
},
{
"filename": "src/prompts/ask.ts",
"retrieved_chunk": "export default promptConfiguration;",
"score": 0.8323736786842346
}
] |
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/executePrompt.ts",
"retrieved_chunk": "): AsyncGenerator<string> {\n const model = toModel(promptConfig);\n const formattedPrompt = promptConfig.createPrompt(input);\n const cacheKey = `${model.id}-${formattedPrompt}`;\n if (cache) {\n const cachedResponse = await cache.get(cacheKey);\n if (cachedResponse) {\n yield cachedResponse;\n return;\n }",
"score": 0.8952645063400269
},
{
"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": 0.8531292676925659
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": " }\n const stream = openAIQuery(model, formattedPrompt, config);\n const chunks = [];\n for await (const chunk of stream) {\n chunks.push(chunk);\n yield chunk;\n }\n if (cache) {\n const response = chunks.join(\"\");\n await cache.set(cacheKey, response);",
"score": 0.8519906997680664
},
{
"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": 0.8446613550186157
},
{
"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": 0.8323466777801514
}
] |
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/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": 0.8755269646644592
},
{
"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": 0.8522145748138428
},
{
"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": 0.8487527966499329
},
{
"filename": "src/executePrompt.ts",
"retrieved_chunk": "): AsyncGenerator<string> {\n const model = toModel(promptConfig);\n const formattedPrompt = promptConfig.createPrompt(input);\n const cacheKey = `${model.id}-${formattedPrompt}`;\n if (cache) {\n const cachedResponse = await cache.get(cacheKey);\n if (cachedResponse) {\n yield cachedResponse;\n return;\n }",
"score": 0.8421396017074585
},
{
"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": 0.8419843912124634
}
] |
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": 0.855205237865448
},
{
"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": 0.8339818716049194
},
{
"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": 0.8310720920562744
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " device.sendReport(\n 0x01,\n new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),\n );\n },\n // timeout: 5000,\n },\n );\n}\nexport async function getNextStrain(joycon: HIDDevice) {",
"score": 0.8291947841644287
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " await rpc(\n {\n kind: 'enterChargeMode',\n request: {},\n },\n ['content'],\n );\n signPower = await rpc(\n {\n kind: 'getSignPower',",
"score": 0.8243988752365112
}
] |
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": 0.8838574290275574
},
{
"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": 0.8350615501403809
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " device.sendReport(\n 0x01,\n new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),\n );\n },\n // timeout: 5000,\n },\n );\n}\nexport async function getNextStrain(joycon: HIDDevice) {",
"score": 0.8346517086029053
},
{
"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": 0.8336477875709534
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // timeout: 5000,\n },\n );\n}\nexport function getStrain(event: HIDInputReportEvent) {\n if (event.reportId === 0x30) {\n return new DataView(event.data.buffer, 38, 2).getInt16(0, true);\n } else {\n return null;\n }",
"score": 0.8285267353057861
}
] |
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": 0.8113157749176025
},
{
"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": 0.7920575737953186
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " neutral,\n },\n },\n };\n chrome.runtime.sendMessage(req);\n };\n const reportListener = (ev: HIDInputReportEvent) => {\n const value = getStrain(ev);\n if (value) {\n sendStrain(value);",
"score": 0.7914501428604126
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " chrome.runtime.onMessage.addListener(listener);\n },\n removeEventListener: (listener) => {\n chrome.runtime.onMessage.removeListener(listener);\n },\n },\n );\n // Stop sending strain signals.\n joycon.removeEventListener('inputreport', reportListener);\n return {",
"score": 0.7814720869064331
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": "import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';\nimport { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';\ninjectResourceScript('js/nip07-provider.js');\n// 'nip07-provider' -> ...\nwindow.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');\n if (!shouldBeHandled) {\n return;\n }\n if (next === 'background') {",
"score": 0.7638986110687256
}
] |
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": 0.8166459798812866
},
{
"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": 0.7978421449661255
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " neutral,\n },\n },\n };\n chrome.runtime.sendMessage(req);\n };\n const reportListener = (ev: HIDInputReportEvent) => {\n const value = getStrain(ev);\n if (value) {\n sendStrain(value);",
"score": 0.7974016070365906
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " chrome.runtime.onMessage.addListener(listener);\n },\n removeEventListener: (listener) => {\n chrome.runtime.onMessage.removeListener(listener);\n },\n },\n );\n // Stop sending strain signals.\n joycon.removeEventListener('inputreport', reportListener);\n return {",
"score": 0.7899391651153564
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": "import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';\nimport { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';\ninjectResourceScript('js/nip07-provider.js');\n// 'nip07-provider' -> ...\nwindow.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');\n if (!shouldBeHandled) {\n return;\n }\n if (next === 'background') {",
"score": 0.7708975076675415
}
] |
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/@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": 0.8522139191627502
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": " unsignedEvent: UnsignedEvent,\n): Promise<SignedEvent> {\n const { created_at, kind, tags, content } = unsignedEvent;\n const id = secp256k1.utils.bytesToHex(\n sha256(utf8Encoder.encode(JSON.stringify([0, pubkey, created_at, kind, tags, content]))),\n );\n const sig = secp256k1.utils.bytesToHex(secp256k1.schnorr.signSync(id, seckey));\n return {\n id,\n pubkey,",
"score": 0.8317655324935913
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " },\n ['content', 'background'],\n );\n return rpc(\n {\n kind: 'signEvent',\n request: event,\n },\n ['content', 'background'],\n );",
"score": 0.8148854970932007
},
{
"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": 0.8075240850448608
},
{
"filename": "src/lib/nostr.ts",
"retrieved_chunk": "import * as secp256k1 from '@noble/secp256k1';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { bech32 } from 'bech32';\nconst utf8Encoder = new TextEncoder();\nsecp256k1.utils.sha256Sync = (...msgs) => sha256(secp256k1.utils.concatBytes(...msgs));\nexport async function calcPubkey(seckey: string): Promise<string> {\n return secp256k1.utils.bytesToHex(secp256k1.schnorr.getPublicKey(seckey));\n}\nexport async function signEvent(\n { seckey, pubkey }: KeyPair,",
"score": 0.8037943840026855
}
] |
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": " device.sendReport(\n 0x01,\n new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),\n );\n },\n // timeout: 5000,\n },\n );\n}\nexport async function getNextStrain(joycon: HIDDevice) {",
"score": 0.8538051247596741
},
{
"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": 0.8482804298400879
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": "import { wait } from './messaging';\nexport async function getJoyconDevice() {\n const [device] = await navigator.hid.requestDevice({\n filters: [\n {\n vendorId: 0x057e, // Nintendo vendor ID\n productId: 0x2007, // joy-con R\n },\n ],\n });",
"score": 0.831673800945282
},
{
"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": 0.8263394832611084
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // get_ext_dev_in_format_config_5C\n await communicate(\n joycon,\n [\n 0x5c, 0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x16, 0xed, 0x34, 0x36, 0x00,\n 0x00, 0x00, 0x0a, 0x64, 0x0b, 0xe6, 0xa9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x90, 0xa8, 0xe1, 0x34, 0x36,\n ],\n [[14, 0x5c]],\n );",
"score": 0.8221333026885986
}
] |
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/lib/ring-con.ts",
"retrieved_chunk": " // timeout: 5000,\n },\n );\n}\nexport function getStrain(event: HIDInputReportEvent) {\n if (event.reportId === 0x30) {\n return new DataView(event.data.buffer, 38, 2).getInt16(0, true);\n } else {\n return null;\n }",
"score": 0.8556302785873413
},
{
"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": 0.8430712223052979
},
{
"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": 0.8240983486175537
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " device.sendReport(\n 0x01,\n new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),\n );\n },\n // timeout: 5000,\n },\n );\n}\nexport async function getNextStrain(joycon: HIDDevice) {",
"score": 0.814468502998352
},
{
"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": 0.8005563020706177
}
] |
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/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": 0.8668698668479919
},
{
"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": 0.8461320400238037
},
{
"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": 0.8430500030517578
},
{
"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": 0.8427866101264954
},
{
"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": 0.8416691422462463
}
] |
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": " 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": 0.8590062856674194
},
{
"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": 0.8509405851364136
},
{
"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": 0.8449116945266724
},
{
"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": 0.8407007455825806
},
{
"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": 0.8385900855064392
}
] |
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/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": 0.8729825019836426
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " kind: 'enterChargeMode';\n request: {};\n response: boolean;\n }\n | {\n // possible paths:\n // - 'content' -> 'background'\n kind: 'openChargeWindow';\n request: {};\n response: number; // tabId",
"score": 0.8613922595977783
},
{
"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": 0.8578978180885315
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": " }\n | {\n // possible paths:\n // - 'charge' -> 'background' -> 'content'\n kind: 'leaveChargeMode';\n request: {\n senderTabId: number;\n };\n response: void;\n };",
"score": 0.8515908122062683
},
{
"filename": "src/@types/common/index.d.ts",
"retrieved_chunk": "}\ninterface _CrxRpcMessageBase {\n ext: ExtName;\n messageId: number;\n}\ntype CrxMessageOrigin = 'nip07-provider' | 'content' | 'background' | 'charge';\ntype CrxRpc =\n | {\n // possible paths:\n // - 'nip07-provider' -> 'content' -> 'background'",
"score": 0.8512636423110962
}
] |
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": 0.8838574290275574
},
{
"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": 0.8350615501403809
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " device.sendReport(\n 0x01,\n new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ...subcommand]),\n );\n },\n // timeout: 5000,\n },\n );\n}\nexport async function getNextStrain(joycon: HIDDevice) {",
"score": 0.8346517086029053
},
{
"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": 0.8336477875709534
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " // timeout: 5000,\n },\n );\n}\nexport function getStrain(event: HIDInputReportEvent) {\n if (event.reportId === 0x30) {\n return new DataView(event.data.buffer, 38, 2).getInt16(0, true);\n } else {\n return null;\n }",
"score": 0.8285267353057861
}
] |
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": 0.8143113851547241
},
{
"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": 0.7970277070999146
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " neutral,\n },\n },\n };\n chrome.runtime.sendMessage(req);\n };\n const reportListener = (ev: HIDInputReportEvent) => {\n const value = getStrain(ev);\n if (value) {\n sendStrain(value);",
"score": 0.7948195934295654
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " chrome.runtime.onMessage.addListener(listener);\n },\n removeEventListener: (listener) => {\n chrome.runtime.onMessage.removeListener(listener);\n },\n },\n );\n // Stop sending strain signals.\n joycon.removeEventListener('inputreport', reportListener);\n return {",
"score": 0.7888498306274414
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": "import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';\nimport { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';\ninjectResourceScript('js/nip07-provider.js');\n// 'nip07-provider' -> ...\nwindow.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {\n const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');\n if (!shouldBeHandled) {\n return;\n }\n if (next === 'background') {",
"score": 0.7694977521896362
}
] |
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/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": 0.8567779064178467
},
{
"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": 0.8495624661445618
},
{
"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": 0.8285014629364014
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " )}\n </TitleContainer>\n {hiddenUser ? (\n <span>\n {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}",
"score": 0.8199402093887329
},
{
"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": 0.8143923282623291
}
] |
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/components/UserPopup/index.tsx",
"retrieved_chunk": "} from './styles';\nimport ExpandMoreIcon from '@mui/icons-material/ExpandMore';\nimport { AuthContextProps } from 'react-oidc-context';\nexport interface UserPopupProps {\n user?: User;\n logoutMethod?(): void;\n auth?: AuthContextProps;\n accountManagementUrl?: string;\n}\nexport const UserPopup = (props: UserPopupProps) => {",
"score": 0.8772558569908142
},
{
"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": 0.8603524565696716
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </LogoutButton>\n </UserPopUpContainer>\n </UserPopUp>\n </ScopedCssBaseline>\n );\n};",
"score": 0.8520616292953491
},
{
"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": 0.8500973582267761
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": "Navbar_.args = {\n h1: true,\n isLandingPage: false,\n haveSearchBar: false,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n iconComponent: () => <></>",
"score": 0.8458737134933472
}
] |
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/stories/Dialog.stories.tsx",
"retrieved_chunk": " <Dialog\n {...args}\n visibility={dialogVisibility}\n rejectFunction={() => setDialogVisibility(!dialogVisibility)}\n acceptFunction={() => setDialogVisibility(!dialogVisibility)}\n />\n )}\n </div>\n );\n};",
"score": 0.8621327877044678
},
{
"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": 0.8518469929695129
},
{
"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": 0.8301984071731567
},
{
"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": 0.8203506469726562
},
{
"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": 0.8200013637542725
}
] |
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/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": 0.8717271089553833
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": "}: FooterProps) => {\n return (\n <ParentFooter>\n <StyledFooter>\n {largeFooter && (\n <LargeDiv>\n <Columns>\n <LeftColumn>\n <LeftColumnText>{title && `${title}`}</LeftColumnText>\n </LeftColumn>",
"score": 0.8675418496131897
},
{
"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": 0.8486789464950562
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " </ParentFooter>\n );\n};",
"score": 0.8459075689315796
},
{
"filename": "src/lib-components/Footer/styles.ts",
"retrieved_chunk": "import styled from \"styled-components\";\nexport const ParentFooter = styled.div`\n display: inline;\n z-index: -10;\n`;\nexport const StyledFooter = styled.div`\n position: sticky;\n min-width: max-content;\n width: 100%;\n bottom: 0;",
"score": 0.8448255062103271
}
] |
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/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": 0.856982946395874
},
{
"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": 0.8548429012298584
},
{
"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": 0.8279526233673096
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " )}\n </TitleContainer>\n {hiddenUser ? (\n <span>\n {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}",
"score": 0.8206550478935242
},
{
"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": 0.8182464241981506
}
] |
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: 'sample@email.com',
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": 0.9063278436660767
},
{
"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": 0.8705485463142395
},
{
"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": 0.8643413782119751
},
{
"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": 0.8512303233146667
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": "import { StoryFn } from '@storybook/react';\nimport { Navbar } from '../lib-components/Navbar';\nimport './storiesGlobals.css';\nimport { SideMenuLink, System, User } from '@/interfaces';\nimport { testLinks, testSystems, testUser } from './sampledata/SampleData';\nimport { BrowserRouter } from 'react-router-dom';\nimport { JSXElementConstructor } from 'react';\nimport EngineeringIcon from '@mui/icons-material/Engineering';\nimport { navbarArgTypes } from './utils/argTypes';\nexport default {",
"score": 0.8470958471298218
}
] |
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/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": 0.8053826093673706
},
{
"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": 0.8050545454025269
},
{
"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": 0.8024817705154419
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " },\n {\n title: 'FrequenCIn',\n IconComponent: () => <FactCheck fontSize='large' htmlColor='#DB1E2F' />,\n description: 'Student Attendance System',\n href: '#'\n },\n {\n title: 'Prints',\n IconComponent: () => <Print fontSize='large' htmlColor='#DB1E2F' />,",
"score": 0.8022213578224182
},
{
"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": 0.7970619201660156
}
] |
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": 0.9384427666664124
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " hiddenUser: boolean;\n user: User;\n h1: boolean;\n sideMenuLinks: SideMenuLink[];\n systemsListPopup: boolean;\n systemsList: System[];\n IconComponent: JSXElementConstructor<any>;\n title: string;\n footerTitle: string;\n footerTelephone: string;",
"score": 0.8992820978164673
},
{
"filename": "src/lib-components/Page/useNavbar.ts",
"retrieved_chunk": " hiddenUser?: boolean;\n title?: string;\n h1?: boolean;\n searchFunction?: (searchString: string) => void;\n searchDropdownLabelsList?: string[];\n logoutFunction?: () => void;\n user?: User;\n sideMenuLinks?: SideMenuLink[];\n isLandingPage?: boolean;\n systemsList?: System[];",
"score": 0.8928737044334412
},
{
"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": 0.8806125521659851
},
{
"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": 0.8805776834487915
}
] |
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/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": 0.8544672131538391
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " })\n );\n }\n }\n const toggleDrawer = () => {\n setVisibility(!visibility);\n };\n const list = (\n <ListWrapper\n style={{",
"score": 0.8522746562957764
},
{
"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": 0.8477898836135864
},
{
"filename": "src/components/HamburgerButton/index.tsx",
"retrieved_chunk": " <Hamburger type='button' onClick={onClick} isOpen={isOpen}>\n <HambTop />\n <HambMiddle />\n <HambBottom />\n </Hamburger>\n );\n};",
"score": 0.8435231447219849
},
{
"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": 0.8410133123397827
}
] |
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": 0.8136881589889526
},
{
"filename": "src/components/SystemsPopup/index.tsx",
"retrieved_chunk": " <SystemItem\n href={system.href}\n key={`system_${system.title}`}\n className='system-item'\n >\n <Tooltip title={system.description} arrow>\n <>\n <IconRenderer\n iconUrl={system.iconUrl}\n alt={system.title}",
"score": 0.8109450340270996
},
{
"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": 0.8084795475006104
},
{
"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": 0.8076133728027344
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " alignItems: centralized ? 'center' : 'normal',\n justifyContent: centralized ? 'center' : 'normal',\n flexDirection: flexDirection ?? 'column',\n flexGrow: 1\n }}\n >\n {haveToast &&\n (components?.toastContainer ? (\n components.toastContainer\n ) : (",
"score": 0.8046747446060181
}
] |
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/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": 0.7996746301651001
},
{
"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": 0.797888994216919
},
{
"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": 0.7959005832672119
},
{
"filename": "src/stories/sampledata/SampleData.tsx",
"retrieved_chunk": " },\n {\n title: 'FrequenCIn',\n IconComponent: () => <FactCheck fontSize='large' htmlColor='#DB1E2F' />,\n description: 'Student Attendance System',\n href: '#'\n },\n {\n title: 'Prints',\n IconComponent: () => <Print fontSize='large' htmlColor='#DB1E2F' />,",
"score": 0.7953501343727112
},
{
"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": 0.7930264472961426
}
] |
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/components/SideMenu/styles.ts",
"retrieved_chunk": " display: flex;\n justify-content: space-evenly;\n align-items: center;\n color: #ffffff;\n text-transform: none;\n text-decoration: none;\n min-width: 100%;\n`;\nexport const NewTabLink = styled.a`\n display: flex;",
"score": 0.8279095888137817
},
{
"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": 0.826241672039032
},
{
"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": 0.8251727223396301
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " border: 3px solid rgb(50, 50, 50);\n scrollbar-color: white;\n background: rgb(50, 50, 50);\n align: center;\n margin: 3px;\n }\n &::-webkit-scrollbar-button {\n }\n`;\nexport const SameTabLink = styled(Link)`",
"score": 0.8197629451751709
},
{
"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": 0.8109719157218933
}
] |
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/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": 0.8962876796722412
},
{
"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": 0.8782939910888672
},
{
"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": 0.8684543371200562
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " <StyledToolbar>\n <LeftContainer>\n {sideMenuLinks.length !== 0 && (\n <HamburgerButton\n isOpen={sideMenuIsOpen}\n onClick={handleToggleSideMenu}\n />\n )}\n <IconRenderer\n iconUrl={currentSystemIconUrl}",
"score": 0.8604370355606079
},
{
"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": 0.8594086170196533
}
] |
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/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": 0.8525702357292175
},
{
"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": 0.8353857398033142
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": "import { useState } from 'react';\nimport { ImageInput } from '../lib-components/ImageInput';\nimport './storiesGlobals.css';\nimport { Meta, StoryFn } from '@storybook/react';\nexport default {\n title: 'Components/ImageInput',\n component: ImageInput\n} as Meta;\nexport const ImageInput_: StoryFn = () => {\n const [file, setFile] = useState<File>(new File([''], 'exemplo.png'));",
"score": 0.8203873038291931
},
{
"filename": "src/components/SearchDropdown/styles.ts",
"retrieved_chunk": " row-gap: 0.75rem;\n padding: 1.5rem;\n border: $border-grey 1px solid;\n box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.25);\n`;\nexport const Field = styled.fieldset`\n border: none;\n display: grid;\n grid-template-columns: 15% 85%;\n height: 2rem;",
"score": 0.807283341884613
},
{
"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": 0.8028087615966797
}
] |
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": 0.911656379699707
},
{
"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": 0.8659062385559082
},
{
"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": 0.8632743954658508
},
{
"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": 0.8455086350440979
},
{
"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": 0.8430001735687256
}
] |
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/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": 0.872732400894165
},
{
"filename": "src/components/Toast/index.tsx",
"retrieved_chunk": "import {\n ToastContainer as ToastifyContainer,\n ToastContainerProps as ToastProps,\n toast\n} from 'react-toastify';\nimport 'react-toastify/dist/ReactToastify.css';\nimport { ToastDiv } from './style';\ninterface ToastContainerProps {\n toastProps: ToastProps;\n topInitialPosition: number;",
"score": 0.8656836152076721
},
{
"filename": "src/components/Toast/style.ts",
"retrieved_chunk": "import styled from \"styled-components\";\nexport const ToastDiv = styled.div.attrs((props: {topSpacing: number}) => props)`\n.Toastify__toast-container--top-right {\n top: ${props => props.topSpacing}px\n}\n`;",
"score": 0.8407410383224487
},
{
"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": 0.8317213654518127
},
{
"filename": "src/components/Toast/index.tsx",
"retrieved_chunk": " );\n};\nexport { toast };",
"score": 0.8302077054977417
}
] |
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/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": 0.8412724733352661
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": "import { useState } from 'react';\nimport { ImageInput } from '../lib-components/ImageInput';\nimport './storiesGlobals.css';\nimport { Meta, StoryFn } from '@storybook/react';\nexport default {\n title: 'Components/ImageInput',\n component: ImageInput\n} as Meta;\nexport const ImageInput_: StoryFn = () => {\n const [file, setFile] = useState<File>(new File([''], 'exemplo.png'));",
"score": 0.8292972445487976
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": " }}\n >\n <span>Nome do arquivo:</span>\n <span>{file.name}</span>\n </div>\n </div>\n );\n};",
"score": 0.8286192417144775
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " <SearchBarContainer>\n {haveSearchBar && (\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}\n type='text'\n value={searchString}\n onChange={handleSearch}\n />",
"score": 0.826296329498291
},
{
"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": 0.8230042457580566
}
] |
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/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": 0.8480203747749329
},
{
"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": 0.8443236947059631
},
{
"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": 0.8425681591033936
},
{
"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": 0.8420102596282959
},
{
"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": 0.8397647142410278
}
] |
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/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": 0.8859208822250366
},
{
"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": 0.8805239200592041
},
{
"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": 0.855649471282959
},
{
"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": 0.8427783250808716
},
{
"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": 0.8389198780059814
}
] |
typescript
|
<ListWrapper
style={{
|
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": 0.934799075126648
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " hiddenUser: boolean;\n user: User;\n h1: boolean;\n sideMenuLinks: SideMenuLink[];\n systemsListPopup: boolean;\n systemsList: System[];\n IconComponent: JSXElementConstructor<any>;\n title: string;\n footerTitle: string;\n footerTelephone: string;",
"score": 0.8931481242179871
},
{
"filename": "src/lib-components/Page/useNavbar.ts",
"retrieved_chunk": " hiddenUser?: boolean;\n title?: string;\n h1?: boolean;\n searchFunction?: (searchString: string) => void;\n searchDropdownLabelsList?: string[];\n logoutFunction?: () => void;\n user?: User;\n sideMenuLinks?: SideMenuLink[];\n isLandingPage?: boolean;\n systemsList?: System[];",
"score": 0.8883774280548096
},
{
"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": 0.87892746925354
},
{
"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": 0.8744673728942871
}
] |
typescript
|
testSystems,
iconComponent: () => <></>
};
|
|
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/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": 0.825291633605957
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " display: flex;\n justify-content: space-evenly;\n align-items: center;\n color: #ffffff;\n text-transform: none;\n text-decoration: none;\n min-width: 100%;\n`;\nexport const NewTabLink = styled.a`\n display: flex;",
"score": 0.8213924765586853
},
{
"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": 0.8192471265792847
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " border: 3px solid rgb(50, 50, 50);\n scrollbar-color: white;\n background: rgb(50, 50, 50);\n align: center;\n margin: 3px;\n }\n &::-webkit-scrollbar-button {\n }\n`;\nexport const SameTabLink = styled(Link)`",
"score": 0.8184714317321777
},
{
"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": 0.8100384473800659
}
] |
typescript
|
<SameTabLink
to={link.href as string}
|
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/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": 0.8617391586303711
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " })\n );\n }\n }\n const toggleDrawer = () => {\n setVisibility(!visibility);\n };\n const list = (\n <ListWrapper\n style={{",
"score": 0.8606561422348022
},
{
"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": 0.857689619064331
},
{
"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": 0.8537589311599731
},
{
"filename": "src/components/HamburgerButton/index.tsx",
"retrieved_chunk": " <Hamburger type='button' onClick={onClick} isOpen={isOpen}>\n <HambTop />\n <HambMiddle />\n <HambBottom />\n </Hamburger>\n );\n};",
"score": 0.8480488061904907
}
] |
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/stories/ForbiddenPage.stories.tsx",
"retrieved_chunk": " redirect_uri: 'https://localhost:3001/'\n };\n const auth = useAuth();\n return (\n <AuthProvider {...authProps}>\n <BrowserRouter>\n <ForbiddenPage auth={auth} />\n </BrowserRouter>\n </AuthProvider>\n );",
"score": 0.8808341026306152
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " const {\n user = { name: 'User Display Name', email: 'user@example.com' },\n logoutMethod,\n auth,\n accountManagementUrl\n } = props;\n function logoutFunction() {\n logoutMethod ? logoutMethod() : auth?.signoutRedirect();\n }\n return (",
"score": 0.8583987355232239
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " logoutMethod={() => {\n setVisibility(true);\n }}\n user={user}\n auth={undefined}\n accountManagementUrl='#'\n />\n </>\n );\n};",
"score": 0.8446372747421265
},
{
"filename": "src/stories/ForbiddenPage.stories.tsx",
"retrieved_chunk": "import { ForbiddenPage } from '../lib-components/ForbiddenPage';\nimport { BrowserRouter } from 'react-router-dom';\nimport { Meta, StoryFn } from '@storybook/react';\nimport {\n AuthContextProps,\n AuthProvider,\n AuthProviderProps,\n useAuth\n} from 'react-oidc-context';\nexport default {",
"score": 0.8431239128112793
},
{
"filename": "src/stories/ForbiddenPage.stories.tsx",
"retrieved_chunk": "interface ForbbidenPageStoryProps {\n auth?: AuthContextProps;\n}\nexport const ForbiddenPage_: StoryFn<ForbbidenPageStoryProps> = () => {\n const mockedKeycloakConfig = JSON.parse(\n '{\"realm\":\"your-realm\",\"auth-server-url\":\"http://your-keycloak-server:8080/\",\"ssl-required\":\"external\",\"resource\":\"your-client\",\"public-client\":true,\"confidential-port\":0}'\n );\n const authProps: AuthProviderProps = {\n authority: mockedKeycloakConfig['auth-server-url'],\n client_id: mockedKeycloakConfig.resource,",
"score": 0.8425624370574951
}
] |
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": 0.8275538682937622
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " alignItems: centralized ? 'center' : 'normal',\n justifyContent: centralized ? 'center' : 'normal',\n flexDirection: flexDirection ?? 'column',\n flexGrow: 1\n }}\n >\n {haveToast &&\n (components?.toastContainer ? (\n components.toastContainer\n ) : (",
"score": 0.8224985003471375
},
{
"filename": "src/lib-components/ForbiddenPage/styles.ts",
"retrieved_chunk": "display: flex;\nflex-direction: column;\njustify-content: center;\nalign-items: center;\n`;",
"score": 0.8222761154174805
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " justify-content: space-evenly;\n align-items: center;\n color: #ffffff;\n text-transform: none;\n text-decoration: none;\n min-width: 100%;\n`;",
"score": 0.8161526322364807
},
{
"filename": "src/components/SystemsPopup/index.tsx",
"retrieved_chunk": " <SystemItem\n href={system.href}\n key={`system_${system.title}`}\n className='system-item'\n >\n <Tooltip title={system.description} arrow>\n <>\n <IconRenderer\n iconUrl={system.iconUrl}\n alt={system.title}",
"score": 0.814595639705658
}
] |
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": 0.9052019715309143
},
{
"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": 0.8905447721481323
},
{
"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": 0.8714941143989563
},
{
"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": 0.8664971590042114
},
{
"filename": "src/stories/Footer.stories.tsx",
"retrieved_chunk": " />\n );\n};\nexport const Footer_ = Template.bind({});\nFooter_.args = {\n footerTitle: 'FOOTER TITLE',\n footerTelephone: '(xx) xxxx-xxxx',\n footerTelephoneComplement: 'Internal number: xxxx / xxxx',\n footerEmail: 'sample@email.com',\n footerLink: 'https://www.google.com',",
"score": 0.8643664121627808
}
] |
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/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": 0.8616827726364136
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " })\n );\n }\n }\n const toggleDrawer = () => {\n setVisibility(!visibility);\n };\n const list = (\n <ListWrapper\n style={{",
"score": 0.8606311678886414
},
{
"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": 0.8575015068054199
},
{
"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": 0.8536286950111389
},
{
"filename": "src/components/HamburgerButton/index.tsx",
"retrieved_chunk": " <Hamburger type='button' onClick={onClick} isOpen={isOpen}>\n <HambTop />\n <HambMiddle />\n <HambBottom />\n </Hamburger>\n );\n};",
"score": 0.8479336500167847
}
] |
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/components/SideMenu/styles.ts",
"retrieved_chunk": " display: flex;\n justify-content: space-evenly;\n align-items: center;\n color: #ffffff;\n text-transform: none;\n text-decoration: none;\n min-width: 100%;\n`;\nexport const NewTabLink = styled.a`\n display: flex;",
"score": 0.8403385877609253
},
{
"filename": "src/lib-components/IconRender/index.tsx",
"retrieved_chunk": " {IconComponent && <IconComponent />}\n </div>\n );\n}",
"score": 0.8186182975769043
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " <ToastContainer\n toastProps={{\n position: 'top-right'\n }}\n topInitialPosition={dimensions.navHeight}\n />\n ))}\n {children}\n </MainDiv>\n </div>",
"score": 0.813694179058075
},
{
"filename": "src/components/SideMenu/styles.ts",
"retrieved_chunk": " border: 3px solid rgb(50, 50, 50);\n scrollbar-color: white;\n background: rgb(50, 50, 50);\n align: center;\n margin: 3px;\n }\n &::-webkit-scrollbar-button {\n }\n`;\nexport const SameTabLink = styled(Link)`",
"score": 0.8120099306106567
},
{
"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": 0.8103988766670227
}
] |
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/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": 0.8632907867431641
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " const [profile, setProfile] = useState<User>(user);\n const contextValue: NavbarContextValue | undefined =\n useContext(NavbarContext);\n if (contextValue) {\n title = contextValue.title ?? title;\n sideMenuLinks = contextValue.sideMenuLinks ?? sideMenuLinks;\n haveSearchBar = contextValue.haveSearchBar ?? haveSearchBar;\n searchFunction = contextValue.searchFunction ?? (() => {});\n }\n useEffect(() => {",
"score": 0.8587184548377991
},
{
"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": 0.846705973148346
},
{
"filename": "src/lib-components/Page/useNavbar.ts",
"retrieved_chunk": " this.logoSrc = navbarProps.logoSrc;\n this.haveSearchBar = navbarProps.haveSearchBar;\n this.hiddenUser = navbarProps.hiddenUser;\n this.title = navbarProps.title;\n this.h1 = navbarProps.h1;\n this.searchFunction = navbarProps.searchFunction;\n this.searchDropdownLabelsList = navbarProps.searchDropdownLabelsList;\n this.logoutFunction = navbarProps.logoutFunction;\n this.user = navbarProps.user;\n this.sideMenuLinks = navbarProps.sideMenuLinks;",
"score": 0.8441798686981201
},
{
"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": 0.8402220606803894
}
] |
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/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": 0.8873217105865479
},
{
"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": 0.8839896321296692
},
{
"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": 0.8491801023483276
},
{
"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": 0.8440088033676147
},
{
"filename": "src/stories/UserPopup.stories.tsx",
"retrieved_chunk": " logoutMethod={() => {\n setVisibility(true);\n }}\n user={user}\n auth={undefined}\n accountManagementUrl='#'\n />\n </>\n );\n};",
"score": 0.8389499187469482
}
] |
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/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": 0.8401903510093689
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": "import { useState } from 'react';\nimport { ImageInput } from '../lib-components/ImageInput';\nimport './storiesGlobals.css';\nimport { Meta, StoryFn } from '@storybook/react';\nexport default {\n title: 'Components/ImageInput',\n component: ImageInput\n} as Meta;\nexport const ImageInput_: StoryFn = () => {\n const [file, setFile] = useState<File>(new File([''], 'exemplo.png'));",
"score": 0.8314484357833862
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": " }}\n >\n <span>Nome do arquivo:</span>\n <span>{file.name}</span>\n </div>\n </div>\n );\n};",
"score": 0.8293643593788147
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " <SearchBarContainer>\n {haveSearchBar && (\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}\n type='text'\n value={searchString}\n onChange={handleSearch}\n />",
"score": 0.8258885145187378
},
{
"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": 0.8249567747116089
}
] |
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/stories/Dialog.stories.tsx",
"retrieved_chunk": " <Dialog\n {...args}\n visibility={dialogVisibility}\n rejectFunction={() => setDialogVisibility(!dialogVisibility)}\n acceptFunction={() => setDialogVisibility(!dialogVisibility)}\n />\n )}\n </div>\n );\n};",
"score": 0.8772634267807007
},
{
"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": 0.8673713803291321
},
{
"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": 0.8451665043830872
},
{
"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": 0.8390958905220032
},
{
"filename": "src/lib-components/Dialog/styles.ts",
"retrieved_chunk": "import styled from 'styled-components';\nimport { Dialog as DialogMui } from '@mui/material';\nexport const StyledDialog = styled(DialogMui)`\n //Componente estilizado criado para tirar o padding do dialog e permitir que a barrinha cole nas margens\n .MuiDialogTitle-root {\n padding: 0;\n }\n .MuiPaper-root {\n max-width: 100vw;\n }",
"score": 0.8299694657325745
}
] |
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": 0.8598055839538574
},
{
"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": 0.8499631285667419
},
{
"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": 0.8206359148025513
},
{
"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": 0.8195403814315796
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " )}\n </TitleContainer>\n {hiddenUser ? (\n <span>\n {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}",
"score": 0.8193920850753784
}
] |
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": 0.8598055839538574
},
{
"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": 0.8499631285667419
},
{
"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": 0.8206359148025513
},
{
"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": 0.8195403814315796
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " )}\n </TitleContainer>\n {hiddenUser ? (\n <span>\n {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}",
"score": 0.8193920850753784
}
] |
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/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": 0.873064398765564
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": "}: FooterProps) => {\n return (\n <ParentFooter>\n <StyledFooter>\n {largeFooter && (\n <LargeDiv>\n <Columns>\n <LeftColumn>\n <LeftColumnText>{title && `${title}`}</LeftColumnText>\n </LeftColumn>",
"score": 0.8678684830665588
},
{
"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": 0.848764181137085
},
{
"filename": "src/lib-components/Footer/index.tsx",
"retrieved_chunk": " )}\n </Columns>\n </LargeDiv>\n )}\n <SmallDiv>\n {copyrightText && (\n <CopyrightText>\n ©{new Date().getFullYear()} {`${copyrightText}`}\n </CopyrightText>\n )}",
"score": 0.8446012139320374
},
{
"filename": "src/lib-components/IconRender/index.tsx",
"retrieved_chunk": " {IconComponent && <IconComponent />}\n </div>\n );\n}",
"score": 0.8442785739898682
}
] |
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/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": 0.8221665620803833
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": "import { useState } from 'react';\nimport { ImageInput } from '../lib-components/ImageInput';\nimport './storiesGlobals.css';\nimport { Meta, StoryFn } from '@storybook/react';\nexport default {\n title: 'Components/ImageInput',\n component: ImageInput\n} as Meta;\nexport const ImageInput_: StoryFn = () => {\n const [file, setFile] = useState<File>(new File([''], 'exemplo.png'));",
"score": 0.821058452129364
},
{
"filename": "src/stories/ImageInput.stories.tsx",
"retrieved_chunk": " }}\n >\n <span>Nome do arquivo:</span>\n <span>{file.name}</span>\n </div>\n </div>\n );\n};",
"score": 0.8155822157859802
},
{
"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": 0.8155204057693481
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " )}\n </TitleContainer>\n {hiddenUser ? (\n <span>\n {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}",
"score": 0.8135173320770264
}
] |
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/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": 0.8948129415512085
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": "Navbar_.args = {\n h1: true,\n isLandingPage: false,\n haveSearchBar: false,\n hiddenUser: false,\n user: testUser,\n sideMenuLinks: testLinks,\n systemsListPopup: false,\n systemsList: testSystems,\n iconComponent: () => <></>",
"score": 0.8873461484909058
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": "export interface NavbarStoryProps {\n isLandingPage: boolean;\n haveSearchBar: boolean;\n hiddenUser: boolean;\n user: User;\n h1: boolean;\n sideMenuLinks: SideMenuLink[];\n systemsListPopup: boolean;\n title: string;\n systemsList: System[];",
"score": 0.8831620216369629
},
{
"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": 0.8729804158210754
},
{
"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": 0.8627725839614868
}
] |
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": 0.9063683748245239
},
{
"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": 0.9017767310142517
},
{
"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": 0.887174665927887
},
{
"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": 0.8850946426391602
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " * `updateTransform` (if defined). For each row updated, retrieves the\n * columns specified in `returnColumns` (if defined), returning them to the\n * caller as an `UpdateReturn`, after transformation by any provided\n * `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.\n * @returns If `returnColumns` is not empty, returns an array containing one\n * object for each row updated; otherwise returns `undefined`.\n */\n returnAll(\n obj: UpdatingObject\n ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;",
"score": 0.8647117614746094
}
] |
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/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": 0.8664308786392212
},
{
"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": 0.8605018854141235
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " this.transforms,\n this.returnColumns\n );\n }\n}",
"score": 0.8589395880699158
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " it('returns SelectedObject with updates returning rows', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, results) => {\n const names = results.name.split(' ');\n return SelectedUser.create(results.id, {\n firstName: names[0],\n lastName: names[1],",
"score": 0.8583670854568481
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " return new TableMapper(db, 'users', {\n insertReturnColumns: ['*'],\n updateReturnColumns: ['*'],\n }).withTransforms({\n countTransform,\n });\n}\nexport function createInsertTransformMapper(db: Kysely<Database>) {\n return new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],",
"score": 0.8567075729370117
}
] |
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": 0.9012883901596069
},
{
"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": 0.8928738832473755
},
{
"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": 0.8845220804214478
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertReturn,\n UpdateReturn,\n this,\n Parameters,\n SubsettingMappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n UpdatingObject,\n UpdateReturnColumns,",
"score": 0.8825106024742126
},
{
"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": 0.8804246783256531
}
] |
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": 0.9209424257278442
},
{
"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": 0.9196416139602661
},
{
"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": 0.9006552696228027
},
{
"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": 0.8967654705047607
},
{
"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": 0.8903887271881104
}
] |
typescript
|
return qb.set(restrictValues(obj, this.columnsToUpdate));
|
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/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": 0.936571478843689
},
{
"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": 0.9096750617027283
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": "export class SubsettingMappingInsertQuery<\n DB,\n TB extends keyof DB & string,\n QB extends InsertQueryBuilder<DB, TB, InsertResult>,\n InsertedObject,\n InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],\n InsertReturn\n> extends MappingInsertQuery<\n DB,\n TB,",
"score": 0.8787651062011719
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertReturn,\n UpdateReturn,\n this,\n Parameters,\n SubsettingMappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n UpdatingObject,\n UpdateReturnColumns,",
"score": 0.8717992305755615
},
{
"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": 0.8715658783912659
}
] |
typescript
|
qb,
columnsToInsert,
this.transforms,
this.returnColumns
);
|
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": " DB,\n TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, returnColumns);",
"score": 0.9061821103096008
},
{
"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": 0.8991197943687439
},
{
"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": 0.8911949992179871
},
{
"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": 0.8833580017089844
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n >\n implements ParameterizableMappingQuery\n{\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToUpdate: Readonly<\n (keyof Updateable<DB[TB]> & string)[]",
"score": 0.879043459892273
}
] |
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/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": 0.9173572063446045
},
{
"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": 0.8954222202301025
},
{
"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": 0.8945409059524536
},
{
"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": 0.8936671018600464
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " InsertedObject,\n InsertReturnColumns,\n InsertReturn\n> {\n constructor(\n db: Kysely<DB>,\n qb: QB,\n transforms: Readonly<\n InsertTransforms<\n DB,",
"score": 0.8853601217269897
}
] |
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": 0.9506787061691284
},
{
"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": 0.9014859199523926
},
{
"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": 0.8735296130180359
},
{
"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": 0.8576685190200806
},
{
"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": 0.8554002642631531
}
] |
typescript
|
= this.instantiateNoReturns(params, transformedObj);
|
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": 0.9502778649330139
},
{
"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": 0.9215754270553589
},
{
"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": 0.9135669469833374
},
{
"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": 0.8846849203109741
},
{
"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": 0.8844761848449707
}
] |
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/update-query.ts",
"retrieved_chunk": " return results.numUpdatedRows !== BigInt(0);\n }\n /**\n * Returns an array of the columns to be updated, with\n * `['*']` indicating that all columns will be updated.\n * @returns An array of the columns to be updated.\n */\n protected getUpdateColumns():\n | Readonly<(keyof Updateable<DB[TB]> & string)[]>\n | ['*'] {",
"score": 0.8985835313796997
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " | ['*'];\n /** Columns to return from the table on update. */\n protected readonly updateReturnColumns:\n | Readonly<SelectionColumn<DB, TB>[]>\n | ['*'];\n /** Query input and output value transforms. */\n protected transforms: TableMapperTransforms<\n DB,\n TB,\n KeyColumns,",
"score": 0.893586277961731
},
{
"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": 0.884665846824646
},
{
"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": 0.8846396207809448
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],\n ReturnCount,\n UpdateReturn\n> {\n #returningQB: UpdateQueryBuilder<DB, TB, TB, any> | null = null;\n constructor(\n readonly db: Kysely<DB>,\n readonly qb: QB,\n protected readonly transforms: Readonly<\n CountTransform<ReturnCount> &",
"score": 0.8815180063247681
}
] |
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": " : applyQueryFilter(\n this.db,\n this.getSelectQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms\n );",
"score": 0.8885113000869751
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " ? this.getDeleteQB()\n : applyQueryFilter(\n this.db,\n this.getDeleteQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms",
"score": 0.8750296831130981
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " this.db,\n this.getUpdateQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms,\n this.updateReturnColumns as UpdateReturnColumns\n );",
"score": 0.8713497519493103
},
{
"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": 0.86540687084198
},
{
"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": 0.8470954298973083
}
] |
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": " : applyQueryFilter(\n this.db,\n this.getSelectQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms\n );",
"score": 0.8854175209999084
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " ? this.getDeleteQB()\n : applyQueryFilter(\n this.db,\n this.getDeleteQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms",
"score": 0.8776159286499023
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " this.db,\n this.getUpdateQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms,\n this.updateReturnColumns as UpdateReturnColumns\n );",
"score": 0.8742140531539917
},
{
"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": 0.8569231033325195
},
{
"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": 0.8484296798706055
}
] |
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": " 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": 0.9495683312416077
},
{
"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": 0.9095907807350159
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " * `updateTransform` (if defined). For each row updated, retrieves the\n * columns specified in `returnColumns` (if defined), returning them to the\n * caller as an `UpdateReturn`, after transformation by any provided\n * `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.\n * @returns If `returnColumns` is not empty, returns an array containing one\n * object for each row updated; otherwise returns `undefined`.\n */\n returnAll(\n obj: UpdatingObject\n ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;",
"score": 0.9033086895942688
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * retrieves the columns specified in `returnColumns`, returning them to\n * the caller as `InsertReturn`, after transformation by\n * `insertReturnTransform`. If `returnColumns` is empty, returns `undefined`.\n * @returns If `returnColumns` is not empty, returns an array containing one\n * object for each inserted object; otherwise returns `undefined`.\n */\n returnAll(\n objs: InsertedObject[]\n ): Promise<InsertReturnColumns extends [] ? void : InsertReturn[]>;\n async returnAll(objs: InsertedObject[]): Promise<InsertReturn[] | void> {",
"score": 0.8783168792724609
},
{
"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": 0.867184042930603
}
] |
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": 0.9506884813308716
},
{
"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": 0.9279269576072693
},
{
"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": 0.9278368949890137
},
{
"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": 0.912895143032074
},
{
"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": 0.8919580578804016
}
] |
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-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": 0.9144768118858337
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " // test deleting a user\n const deleted = await userMapper\n .delete({ id: insertReturn.serialNo })\n .run();\n expect(deleted).toEqual(true);\n const selectedUser3 = await userMapper\n .select({ id: insertReturn.serialNo })\n .returnOne();\n expect(selectedUser3).toBeNull();\n });",
"score": 0.9072460532188416
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " expect(users[1].handle).toEqual(USERS[0].handle);\n const user = await userMapper\n .select()\n .modify((qb) =>\n qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')\n )\n .returnOne();\n expect(user?.handle).toEqual(USERS[2].handle);\n });\n it('does not modify the underlying selected columns', async () => {",
"score": 0.9023752808570862
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " await userMapper.insert().run(USERS);\n // Test selecting by condition (with results)\n let users = await userMapper.select('name', '=', USERS[0].name).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)\n users = await userMapper.select('name', '=', 'nonexistent').returnAll();\n expect(users.length).toEqual(0);\n });",
"score": 0.9007205367088318
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " expect(readUsers[1].email).toEqual(null);\n });\n it('compiles a returning insert query without transformation', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n // test returnOne()\n const insertReturn = await compilation.returnOne(USERS[0]);\n expect(insertReturn).toEqual({ ...USERS[0], id: 1 });",
"score": 0.8994200229644775
}
] |
typescript
|
, param }) => mapper.delete({ name: param('targetName') })
);
|
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": " this.db,\n this.getUpdateQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms,\n this.updateReturnColumns as UpdateReturnColumns\n );",
"score": 0.828866720199585
},
{
"filename": "src/lib/query-filter.ts",
"retrieved_chunk": " */\nexport type QueryFilter<\n DB,\n TB extends keyof DB & string,\n KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,\n RE extends ReferenceExpression<DB, TB>\n> =\n | (KeyColumns extends [string]\n ? KeyColumnFilter<DB, TB, KeyColumns[0]>\n : never)",
"score": 0.8280847072601318
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " : applyQueryFilter(\n this.db,\n this.getSelectQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms\n );",
"score": 0.8272303342819214
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " ? this.getDeleteQB()\n : applyQueryFilter(\n this.db,\n this.getDeleteQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms",
"score": 0.8241267800331116
},
{
"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": 0.8166252374649048
}
] |
typescript
|
if (keyColumns.length === 1) {
|
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": " */\nexport type QueryFilter<\n DB,\n TB extends keyof DB & string,\n KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,\n RE extends ReferenceExpression<DB, TB>\n> =\n | (KeyColumns extends [string]\n ? KeyColumnFilter<DB, TB, KeyColumns[0]>\n : never)",
"score": 0.8431216478347778
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " : applyQueryFilter(\n this.db,\n this.getSelectQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms\n );",
"score": 0.8406291604042053
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " this.db,\n this.getUpdateQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms,\n this.updateReturnColumns as UpdateReturnColumns\n );",
"score": 0.8403217792510986
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " ? this.getDeleteQB()\n : applyQueryFilter(\n this.db,\n this.getDeleteQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms",
"score": 0.8359037637710571
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " >;\n update<RE extends ReferenceExpression<DB, TB>>(\n filter?: QueryFilter<DB, TB, KeyColumns, RE>\n ): AnyColumnsMappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,",
"score": 0.825456976890564
}
] |
typescript
|
return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) 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-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": 0.9136672019958496
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " // test deleting a user\n const deleted = await userMapper\n .delete({ id: insertReturn.serialNo })\n .run();\n expect(deleted).toEqual(true);\n const selectedUser3 = await userMapper\n .select({ id: insertReturn.serialNo })\n .returnOne();\n expect(selectedUser3).toBeNull();\n });",
"score": 0.9061962366104126
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " expect(users[1].handle).toEqual(USERS[0].handle);\n const user = await userMapper\n .select()\n .modify((qb) =>\n qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')\n )\n .returnOne();\n expect(user?.handle).toEqual(USERS[2].handle);\n });\n it('does not modify the underlying selected columns', async () => {",
"score": 0.9008908271789551
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " expect(readUsers[1].email).toEqual(null);\n });\n it('compiles a returning insert query without transformation', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n // test returnOne()\n const insertReturn = await compilation.returnOne(USERS[0]);\n expect(insertReturn).toEqual({ ...USERS[0], id: 1 });",
"score": 0.89922696352005
},
{
"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": 0.8981471657752991
}
] |
typescript
|
{ mapper, param }) => mapper.delete({ name: param('targetName') })
);
|
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: 'jdoe@abc.def',
});
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: 'jdoe@abc.def',
});
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: 'jdoe@abc.def',
});
});
});
|
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": 0.94832843542099
},
{
"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": 0.9323335289955139
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " .columns(['name'] as const); // allows readonly array\n const updateReturns = await subsetQuery.returnAll(updateValues);\n expect(updateReturns).toEqual([{ id: insertReturns[0].id }]);\n const readUsers = await userMapperReturningID\n .select('id', '=', insertReturns[0].id)\n .returnOne();\n expect(readUsers).toEqual({\n id: insertReturns[0].id,\n name: 'Sue Rex',\n email: USERS[0].email,",
"score": 0.9106080532073975
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " handle: USERS[0].handle,\n });\n });\n it('subsets updating columns, including ID', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { id: 100, name: 'Sue Rex', email: 'rex@abc.def' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['id', 'name', 'email']);\n const updateReturns = await subsetQuery.returnAll(updateValues);",
"score": 0.9103424549102783
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(insertReturns).toEqual([2, 3]);\n // ensure return type can be accessed as a number\n ((_: number) => {})(insertReturns[0]);\n });\n it(\"transforms insertion and insertion return, columns is ['*']\", async () => {\n expect.assertions(5);\n const insertAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser, columns) => {",
"score": 0.894182026386261
}
] |
typescript
|
insertTransform: (source, columns) => {
|
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/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": 0.8920999765396118
},
{
"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": 0.8861225247383118
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n >\n implements ParameterizableMappingQuery\n{\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToUpdate: Readonly<\n (keyof Updateable<DB[TB]> & string)[]",
"score": 0.8856968879699707
},
{
"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": 0.8840523958206177
},
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }\n /**\n * Returns a mapping query that only updates a specified subset of columns.\n * @param columns The columns to update. All are required, but this\n * constraint is only enforced at runtime, not by the type system.",
"score": 0.8813614249229431
}
] |
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": " 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": 0.8982572555541992
},
{
"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": 0.8902390599250793
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " // test deleting a user\n const deleted = await userMapper\n .delete({ id: insertReturn.serialNo })\n .run();\n expect(deleted).toEqual(true);\n const selectedUser3 = await userMapper\n .select({ id: insertReturn.serialNo })\n .returnOne();\n expect(selectedUser3).toBeNull();\n });",
"score": 0.8863879442214966
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const filter1 = { name: 'Not There' as const } as const;\n await userMapper.select(filter1).returnAll();\n await userMapper.select(filter1).returnOne();\n const filter2 = { name: ['name1', 'name2'] as const } as const;\n await userMapper.select(filter2).returnAll();\n await userMapper.select(filter2).returnOne();\n });\n it('selects nothing when nothing matches filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper.select({ name: 'Not There' }).returnAll();",
"score": 0.883831262588501
},
{
"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": 0.8833587765693665
}
] |
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": " * @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": 0.8630205988883972
},
{
"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": 0.8591850399971008
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " if (this.returnColumns.length === 0) {\n await this.loadInsertedObjects(this.qb, objs).execute();\n return;\n }\n const returns = await this.loadInsertedObjects(\n this.getReturningQB(),\n objs\n ).execute();\n return this.transforms.insertReturnTransform === undefined\n ? (returns as any)",
"score": 0.8575451970100403
},
{
"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": 0.8562076687812805
},
{
"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": 0.8520926237106323
}
] |
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/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": 0.9376028776168823
},
{
"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": 0.9262316823005676
},
{
"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": 0.9195935130119324
},
{
"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": 0.9075459241867065
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " InsertedObject,\n InsertReturnColumns,\n InsertReturn\n> {\n constructor(\n db: Kysely<DB>,\n qb: QB,\n transforms: Readonly<\n InsertTransforms<\n DB,",
"score": 0.900633692741394
}
] |
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: 'abc@def.ghi' 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: 'xyz@pdq.xyz' }]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{ email: 'xyz@pdq.xyz' }]);
// @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/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": 0.9450969099998474
},
{
"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": 0.9342057704925537
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " const readUsers = await insertTransformMapper\n .select('id', '>', insertReturn.id)\n .returnAll();\n expect(readUsers.length).toEqual(2);\n expect(readUsers[0].name).toEqual(\n `${insertedUser2.firstName} ${insertedUser2.lastName}`\n );\n expect(readUsers[1].name).toEqual(\n `${insertedUser3.firstName} ${insertedUser3.lastName}`\n );",
"score": 0.9303015470504761
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " await userMapperReturningID.insert().run(USERS[1]);\n await userMapperReturningID.insert().run(USERS[2]);\n const updateCount1 = await userMapperReturningAll\n .update({ id: insertReturn0.id })\n .returnCount(updateValues);\n expect(updateCount1).toEqual(1);\n const readUser1 = await userMapperReturningID\n .select('id', '=', insertReturn0.id)\n .returnOne();\n expect(readUser1?.email).toEqual(updateValues.email);",
"score": 0.9236693382263184
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const users = await mapper.select({ name: USERS[0].name }).returnAll();\n expect(users).toEqual([\n {\n id: ids[0].id,\n h: USERS[0].handle,\n },\n {\n id: ids[2].id,\n h: USERS[2].handle,\n },",
"score": 0.9221525192260742
}
] |
typescript
|
const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id });
|
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 </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": 0.8852937817573547
},
{
"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": 0.8543263673782349
},
{
"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": 0.8463360071182251
},
{
"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": 0.8448888659477234
},
{
"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": 0.8372713327407837
}
] |
typescript
|
Dialog
{...args}
|
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 );\n }\n }\n const toggleDrawer = () => {\n setVisibility(!visibility);\n };\n const list = (\n <ListWrapper\n style={{",
"score": 0.8995577096939087
},
{
"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": 0.8860558271408081
},
{
"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": 0.8827463388442993
},
{
"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": 0.8809530138969421
},
{
"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": 0.8808630108833313
}
] |
typescript
|
<SideMenu
visibility={drawerVisibility}
|
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: 'abc@def.hij',
// @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',
'jdoe@abc.def'
);
const user2: Readonly<User> = new User(
0,
'Sam',
'Gamgee',
'sg',
'sg@abc.def'
);
const user3 = new User(100, 'Sue', 'Rex', 'srex', 'srex@abc.def');
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": 0.9229774475097656
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(insertReturns).toEqual([2, 3]);\n // ensure return type can be accessed as a number\n ((_: number) => {})(insertReturns[0]);\n });\n it(\"transforms insertion and insertion return, columns is ['*']\", async () => {\n expect.assertions(5);\n const insertAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser, columns) => {",
"score": 0.907990574836731
},
{
"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": 0.9004693627357483
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(insertReturn).toEqual({ id: expect.any(Number) });\n const readUser = await userMapperReturningID.select().returnAll();\n expect(readUser).toEqual([\n { id: 1, name: 'John Doe', handle: 'johndoe', email: null },\n ]);\n });\n it('subsets inserted columns, including ID', async () => {\n const subsetQuery = userMapperReturningNothing\n .insert()\n .columns(['id', 'name', 'handle']);",
"score": 0.8963626027107239
},
{
"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": 0.8894650340080261
}
] |
typescript
|
const columnSubset: (keyof Insertable<Users>)[] = [
'name',
'handle',
'email',
];
|
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/components/UserPopup/index.tsx",
"retrieved_chunk": " const {\n user = { name: 'User Display Name', email: 'user@example.com' },\n logoutMethod,\n auth,\n accountManagementUrl\n } = props;\n function logoutFunction() {\n logoutMethod ? logoutMethod() : auth?.signoutRedirect();\n }\n return (",
"score": 0.8547245264053345
},
{
"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": 0.8487673997879028
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </LogoutButton>\n </UserPopUpContainer>\n </UserPopUp>\n </ScopedCssBaseline>\n );\n};",
"score": 0.8452740907669067
},
{
"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": 0.8363523483276367
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": " <Dialog\n {...args}\n visibility={dialogVisibility}\n rejectFunction={() => setDialogVisibility(!dialogVisibility)}\n acceptFunction={() => setDialogVisibility(!dialogVisibility)}\n />\n )}\n </div>\n );\n};",
"score": 0.8327702879905701
}
] |
typescript
|
<UserPopup
logoutMethod={() => {
|
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: 'sample@email.com',
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": 0.8906081318855286
},
{
"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": 0.8625185489654541
},
{
"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": 0.8619609475135803
},
{
"filename": "src/stories/Navbar.stories.tsx",
"retrieved_chunk": "import { StoryFn } from '@storybook/react';\nimport { Navbar } from '../lib-components/Navbar';\nimport './storiesGlobals.css';\nimport { SideMenuLink, System, User } from '@/interfaces';\nimport { testLinks, testSystems, testUser } from './sampledata/SampleData';\nimport { BrowserRouter } from 'react-router-dom';\nimport { JSXElementConstructor } from 'react';\nimport EngineeringIcon from '@mui/icons-material/Engineering';\nimport { navbarArgTypes } from './utils/argTypes';\nexport default {",
"score": 0.8504303693771362
},
{
"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": 0.8457509875297546
}
] |
typescript
|
Page
navbar={{
|
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: 'xyz@pdq.xyz' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: 'xyz@pdq.xyz' });
// @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-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": 0.929140567779541
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " 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 });\n it('inserts multiple explicitly returning no columns', async () => {\n const insertReturns = await userMapperReturningNothing\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();",
"score": 0.9144856929779053
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " result[0].id;\n });\n });\n it('inserts multiple via returnAll() without returning columns', async () => {\n const results = await userMapperReturningDefault.insert().returnAll(USERS);\n expect(results).toBeUndefined();\n 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);",
"score": 0.9139010906219482
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " name: 'John Doe' as const,\n handle: 'johndoe' as const,\n email: 'abc@def.ghi' as const,\n } as const;\n await userMapperReturningAll.insert().run(obj);\n await userMapperReturningAll.insert().returnAll([obj]);\n await userMapperReturningAll.insert().returnOne(obj);\n });\n it('inserts multiple via run() without returning columns', async () => {\n const success = await userMapperReturningDefault.insert().run(USERS);",
"score": 0.9132223129272461
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " results[0].id;\n });\n });\n it('inserts multiple returning configured return columns', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n expect(insertReturns.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(insertReturns[i].id).toBeGreaterThan(0);\n expect(Object.keys(insertReturns[i]).length).toEqual(1);\n }",
"score": 0.9108074903488159
}
] |
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": 0.9429634809494019
},
{
"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": 0.9275760054588318
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(insertReturn).toEqual({ id: expect.any(Number) });\n const readUser = await userMapperReturningID.select().returnAll();\n expect(readUser).toEqual([\n { id: 1, name: 'John Doe', handle: 'johndoe', email: null },\n ]);\n });\n it('subsets inserted columns, including ID', async () => {\n const subsetQuery = userMapperReturningNothing\n .insert()\n .columns(['id', 'name', 'handle']);",
"score": 0.9128764867782593
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " 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 });\n it('inserts multiple explicitly returning no columns', async () => {\n const insertReturns = await userMapperReturningNothing\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();",
"score": 0.9113367795944214
},
{
"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": 0.9101082682609558
}
] |
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/insert-compile.test.ts",
"retrieved_chunk": " expect(readUsers[1].email).toEqual(null);\n });\n it('compiles a returning insert query without transformation', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n // test returnOne()\n const insertReturn = await compilation.returnOne(USERS[0]);\n expect(insertReturn).toEqual({ ...USERS[0], id: 1 });",
"score": 0.9256611466407776
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " 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 });\n it('inserts multiple explicitly returning no columns', async () => {\n const insertReturns = await userMapperReturningNothing\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();",
"score": 0.9247324466705322
},
{
"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": 0.9238578677177429
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user1\n );\n const expectedReturn3 = {\n id: insertReturns[2].id,\n firstName: user1.firstName,\n lastName: user1.lastName,\n };\n expect(success1).toBe(true);\n // verify updates\n const readUsers = await transformMapper.select().returnAll();",
"score": 0.9229655265808105
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user2\n );\n expect(count).toEqual(1);\n const readUser = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser).toEqual(\n User.create(insertReturns[2].id, {\n ...expectedReturn1,\n handle: user3.handle,",
"score": 0.9204675555229187
}
] |
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: 'xyz@pdq.xyz' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: 'xyz@pdq.xyz' });
// @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/update-general.test.ts",
"retrieved_chunk": " await userMapperReturningID.insert().run(USERS[1]);\n await userMapperReturningID.insert().run(USERS[2]);\n const updateCount1 = await userMapperReturningAll\n .update({ id: insertReturn0.id })\n .returnCount(updateValues);\n expect(updateCount1).toEqual(1);\n const readUser1 = await userMapperReturningID\n .select('id', '=', insertReturn0.id)\n .returnOne();\n expect(readUser1?.email).toEqual(updateValues.email);",
"score": 0.9574519395828247
},
{
"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": 0.950164794921875
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " await userMapperReturningID.insert().run(USERS);\n const updates = await userMapperReturningNothing\n .update({ name: 'Sue' })\n .returnAll({ email: 'new.email@xyz.pdq' });\n expect(updates).toBeUndefined();\n const readUsers = await userMapperReturningID\n .select({\n email: 'new.email@xyz.pdq',\n })\n .returnAll();",
"score": 0.9351159334182739
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const readUser2 = await userMapperReturningID\n .select('id', '=', 1)\n .returnOne();\n expect(readUser2?.name).toEqual('Every User 2');\n const updateCount = await userMapperReturningID.update().returnCount({\n name: 'Every User 3',\n });\n expect(updateCount).toEqual(3);\n const success = await userMapperReturningID.update().run({\n name: 'Every User 4',",
"score": 0.9334249496459961
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " .select({\n id: insertReturn.id,\n })\n .returnOne();\n expect(readUser1?.name).toEqual(\n `${insertedUser1.firstName} ${insertedUser1.lastName}`\n );\n await insertTransformMapper\n .insert()\n .returnAll([insertedUser2, insertedUser3]);",
"score": 0.9294094443321228
}
] |
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": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.9296978116035461
},
{
"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": 0.9228427410125732
},
{
"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": 0.9199758768081665
},
{
"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": 0.9186442494392395
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " ((_: string) => {})(updateReturns[0].name);\n ignore('type errors', () => {\n // @ts-expect-error - check return types\n insertReturns[0].name;\n // @ts-expect-error - check return types\n updateReturns[0].id;\n });\n });\n it('inserts multiple configured to return all columns', async () => {\n const insertReturns = await userMapperReturningAll",
"score": 0.9183064699172974
}
] |
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": 0.9331797361373901
},
{
"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": 0.9199092388153076
},
{
"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": 0.9188799858093262
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.9161489009857178
},
{
"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": 0.9122501611709595
}
] |
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": 0.931037425994873
},
{
"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": 0.916487455368042
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " ((_: string) => {})(updateReturns[0].name);\n ignore('type errors', () => {\n // @ts-expect-error - check return types\n insertReturns[0].name;\n // @ts-expect-error - check return types\n updateReturns[0].id;\n });\n });\n it('inserts multiple configured to return all columns', async () => {\n const insertReturns = await userMapperReturningAll",
"score": 0.913350522518158
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " // Ensure that returned objects can be accessed as expected.\n ((_: string) => {})(insertReturns[0].name);\n });\n ignore('detects inserting an array of objects type errors', async () => {\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().returnAll([{}]);\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().run([{}]);\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().returnAll([{ email: 'xyz@pdq.xyz' }]);",
"score": 0.9118813872337341
},
{
"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": 0.9087910652160645
}
] |
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-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": 0.9251793622970581
},
{
"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": 0.9209030866622925
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.920808732509613
},
{
"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": 0.9113739132881165
},
{
"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": 0.9105879068374634
}
] |
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": 0.9734101891517639
},
{
"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": 0.9389184713363647
},
{
"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": 0.925796389579773
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - where expression columns must be valid\n or([cmpr('notThere', '=', 'Sue')])\n );\n // @ts-expect-error - binary op filter fields must be valid\n userMapper.select('notThere', '=', 'foo');\n // @ts-expect-error - binary op filter fields must be valid\n userMapper.select('users.notThere', '=', 'foo');\n // @ts-expect-error - ID filter must have correct type\n userMapper.select('str');\n // @ts-expect-error - ID filter must have correct type",
"score": 0.9111756086349487
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " // @ts-expect-error - only table columns are accessible via allOf()\n or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])\n );\n // @ts-expect-error - ID filter must have correct type\n userMapper.delete('str');\n // @ts-expect-error - ID filter must have correct type\n userMapper.delete(['str']);\n // @ts-expect-error - ID filter not allowed when when no ID column\n userMapperReturningNothing.delete(1);\n // @ts-expect-error - ID filter not allowed when when no ID column",
"score": 0.8917509913444519
}
] |
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": " });\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": 0.9221768379211426
},
{
"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": 0.9177118539810181
},
{
"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": 0.909917414188385
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(insertReturn!.name);\n // test run()\n const success1 = await compilation.run(USERS[1]);\n expect(success1).toBe(true);\n // test that non-specified columns are not inserted\n const success2 = await compilation.run({ ...USERS[2], id: 100 });\n expect(success2).toBe(true);\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);",
"score": 0.9066798686981201
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const filter1 = { name: 'Not There' as const } as const;\n await userMapper.select(filter1).returnAll();\n await userMapper.select(filter1).returnOne();\n const filter2 = { name: ['name1', 'name2'] as const } as const;\n await userMapper.select(filter2).returnAll();\n await userMapper.select(filter2).returnOne();\n });\n it('selects nothing when nothing matches filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper.select({ name: 'Not There' }).returnAll();",
"score": 0.9051779508590698
}
] |
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', 'x@y.z'),
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', 'jdoe@abc.def')))!.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": " 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": 0.909458577632904
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " });\n const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');\n const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');\n const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');\n const insertReturns = await transformMapper\n .insert()\n .returnAll([user1, user2, user3]);\n const parameterization = transformMapper.parameterize<{ id: number }>(\n ({ mapper, param }) =>\n mapper.update({ id: param('id') }).columns(['name'])",
"score": 0.9086927175521851
},
{
"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": 0.9075437188148499
},
{
"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": 0.9005608558654785
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n countTransform: (count) => Number(count),\n });\n}",
"score": 0.8966846466064453
}
] |
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": " });\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": 0.9242663979530334
},
{
"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": 0.9153851270675659
},
{
"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": 0.9111166000366211
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(insertReturn!.name);\n // test run()\n const success1 = await compilation.run(USERS[1]);\n expect(success1).toBe(true);\n // test that non-specified columns are not inserted\n const success2 = await compilation.run({ ...USERS[2], id: 100 });\n expect(success2).toBe(true);\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);",
"score": 0.9047672748565674
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const filter1 = { name: 'Not There' as const } as const;\n await userMapper.select(filter1).returnAll();\n await userMapper.select(filter1).returnOne();\n const filter2 = { name: ['name1', 'name2'] as const } as const;\n await userMapper.select(filter2).returnAll();\n await userMapper.select(filter2).returnOne();\n });\n it('selects nothing when nothing matches filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper.select({ name: 'Not There' }).returnAll();",
"score": 0.9005703330039978
}
] |
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": " (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": 0.9462583661079407
},
{
"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": 0.9456337094306946
},
{
"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": 0.9409661889076233
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - where expression columns must be valid\n or([cmpr('notThere', '=', 'Sue')])\n );\n // @ts-expect-error - binary op filter fields must be valid\n userMapper.select('notThere', '=', 'foo');\n // @ts-expect-error - binary op filter fields must be valid\n userMapper.select('users.notThere', '=', 'foo');\n // @ts-expect-error - ID filter must have correct type\n userMapper.select('str');\n // @ts-expect-error - ID filter must have correct type",
"score": 0.9095673561096191
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const filter1 = { name: 'Not There' as const } as const;\n await userMapper.select(filter1).returnAll();\n await userMapper.select(filter1).returnOne();\n const filter2 = { name: ['name1', 'name2'] as const } as const;\n await userMapper.select(filter2).returnAll();\n await userMapper.select(filter2).returnOne();\n });\n it('selects nothing when nothing matches filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper.select({ name: 'Not There' }).returnAll();",
"score": 0.9029140472412109
}
] |
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: 'rex@abc.def' };
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: 'rex@abc.def' };
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: 'rex@abc.def',
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: 'jdoe@abc.def',
});
});
});
|
src/tests/update-columns.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"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": 0.9257248640060425
},
{
"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": 0.9106893539428711
},
{
"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": 0.9101039171218872
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " it('subsets inserted columns, excluding ID', async () => {\n const subsetQuery = userMapperReturningID\n .insert()\n .columns(['name', 'handle'] as const); // allows readonly array\n const insertReturn = await subsetQuery.returnOne({\n id: 10,\n name: 'John Doe',\n handle: 'johndoe',\n email: 'jdoe@abc.def',\n });",
"score": 0.8930131793022156
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(insertReturn).toEqual({ id: expect.any(Number) });\n const readUser = await userMapperReturningID.select().returnAll();\n expect(readUser).toEqual([\n { id: 1, name: 'John Doe', handle: 'johndoe', email: null },\n ]);\n });\n it('subsets inserted columns, including ID', async () => {\n const subsetQuery = userMapperReturningNothing\n .insert()\n .columns(['id', 'name', 'handle']);",
"score": 0.8917598724365234
}
] |
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.