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 { Config, Model } from "./types.js";
import {
ChatCompletionRequestMessageRoleEnum,
Configuration,
OpenAIApi,
} from "openai";
import { ApiError } from "./errors.js";
import { asyncIterableToArray } from "./utils.js";
// https://2ality.com/2018/04/async-iter-nodejs.html#generator-%231%3A-from-chunks-to-lines
async function* chunksToLines(chunksAsync: AsyncGenerator<string>) {
let previous = "";
for await (const chunk of chunksAsync) {
const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
previous += bufferChunk;
let eolIndex;
while ((eolIndex = previous.indexOf("\n")) >= 0) {
// line includes the EOL
const line = previous.slice(0, eolIndex + 1).trimEnd();
if (line === "data: [DONE]") break;
if (line.startsWith("data: ")) {
yield line.slice("data: ".length);
}
previous = previous.slice(eolIndex + 1);
}
}
}
// Wraps openai and provides streaming API + auto selection of api function based on model
export async function* openAIQuery(
model: Model,
prompt: string,
config: Config
): AsyncGenerator<string> {
const openai = new OpenAIApi(
new Configuration({
apiKey: config.openai.apiKey,
})
);
// TODO: select right api route/function based on model
const opts = {
stream: true,
model: model.id,
messages: [
{
role: ChatCompletionRequestMessageRoleEnum.System,
content: prompt,
},
],
};
const res = await (async () => {
try {
return await openai.createChatCompletion(opts, {
responseType: "stream",
});
} catch (err) {
if (err instanceof Error) {
if ("isAxiosError" in err) {
/* @ts-ignore */
const data = await asyncIterableToArray(err.response.data);
const error = JSON.parse(data.toString()).error;
| throw new ApiError(error); |
}
}
throw err;
}
})();
/* @ts-ignore */
const stream = res.data as IncomingMessage;
for await (const chunk of chunksToLines(stream)) {
const data = JSON.parse(chunk);
const content = data.choices[0].delta.content;
// console.log({ json });
if (content) {
yield content;
}
}
}
| src/openai.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " .filter((f) => f.endsWith(\".js\") || f.endsWith(\".mjs\"))\n .map((filename) => pathJoin(path, filename));\n } catch (err) {\n if (err instanceof Error && \"code\" in err) {\n if (err.code == \"ENOENT\") {\n // ignore error: ENOENT: no such file or directory\n return [];\n }\n }\n throw err;",
"score": 0.810472846031189
},
{
"filename": "src/errors.ts",
"retrieved_chunk": "}\nexport class AppError extends Error {\n cause?: Error;\n exitCode = 1;\n private static wrap(err: unknown) {\n // We don't wrap errors that indicate unexpected/programming errors\n if (isProgrammingError(err)) {\n return err;\n }\n const cause = err instanceof Error ? err : undefined;",
"score": 0.7801560163497925
},
{
"filename": "src/kvs/kvs-filesystem.ts",
"retrieved_chunk": " await this.waitInit;\n const filePath = this._keyToFilePath(key);\n try {\n const val = await readFile(filePath, \"utf8\");\n return val;\n } catch (err) {\n return;\n }\n }\n async delete(key: K) {",
"score": 0.775414228439331
},
{
"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.7661147117614746
},
{
"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.7544729709625244
}
] | typescript | throw new ApiError(error); |
import { executePrompt, executePromptStream } from "./executePrompt.js";
import { loadConfig } from "./config.js";
import { loadPromptConfig, listPrompts } from "./loadPromptConfig.js";
import { APPNAME } from "./types.js";
import FileSystemKVS from "./kvs/kvs-filesystem.js";
import { AppError } from "./errors.js";
import { readFileSync } from "node:fs";
function parseArgs(argv: string[]) {
const [_nodeBin, _jsFile, promptId, ...rest] = argv;
const input = rest.join(" ");
return { promptId, input };
}
function printUsageAndExit() {
console.log("Usage:");
console.log(`$ ${APPNAME} <promptType> <input>`);
console.log(`$ ${APPNAME} --list`);
console.log("");
console.log("Example: ");
console.log("");
console.log(`$ ${APPNAME} eli5 "what are large language models?"`);
process.exit(1);
}
function getInput(argvInput: string) {
try {
const stdinInput = readFileSync(process.stdin.fd, "utf-8");
// console.log({ stdinInput });
return `${argvInput} ${stdinInput}`;
} catch (err) {
return argvInput;
}
}
export async function cli() {
try {
const config = loadConfig();
const { promptId, input: argvInput } = parseArgs(process.argv);
if (promptId === "--list") {
const prompts = await listPrompts(config);
console.log(
prompts
| .map((p) => { |
const description = p.description ? `: ${p.description}` : "";
return `${p.name}${description}`;
})
.join("\n")
);
return;
} else if (promptId && promptId.startsWith("--")) {
printUsageAndExit();
}
const input = getInput(argvInput);
if (!promptId || !input) {
printUsageAndExit();
}
const promptConfig = await loadPromptConfig(promptId, config);
const cache = config.useCache
? new FileSystemKVS({ baseDir: config.paths.cache })
: undefined;
const stream = executePromptStream(promptConfig, input, config, cache);
for await (const chunk of stream) {
process.stdout.write(chunk);
}
process.stdout.write("\n");
} catch (err) {
if (err instanceof AppError) {
console.error(err.toString());
process.exit(err.exitCode);
}
console.error(err);
process.exit(1);
}
}
export default cli;
| src/index.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " ]);\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.851628303527832
},
{
"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.8139151334762573
},
{
"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.8023682832717896
},
{
"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.7960587739944458
},
{
"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.7947008609771729
}
] | typescript | .map((p) => { |
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": "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.6975257992744446
},
{
"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.6874874830245972
},
{
"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.6739814877510071
},
{
"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.6667726635932922
},
{
"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.6653575301170349
}
] | 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/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.8920698165893555
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " timeout?: number;\n },\n) {\n return new Promise<T>((resolve, reject) => {\n const timeoutId = params.timeout\n ? setTimeout(() => {\n params.removeEventListener(listener);\n reject('timed out');\n })\n : -1;",
"score": 0.841856837272644
},
{
"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.841374397277832
},
{
"filename": "src/background/index.ts",
"retrieved_chunk": " getKeyPair().then(({ pubkey }) => {\n sendResponse(pubkey);\n });\n return true; // For async response\n case 'signEvent':\n getKeyPair().then(async (keypair) => {\n const signed = await signEvent(keypair, payload.request);\n sendResponse(signed);\n });\n return true;",
"score": 0.8248342871665955
},
{
"filename": "src/resource/nip07-provider.ts",
"retrieved_chunk": " request: {},\n },\n ['content', 'background'],\n );\n }\n if (signPower > 0) {\n rpc(\n {\n kind: 'setSignPower',\n request: { value: signPower - 1 },",
"score": 0.8218057751655579
}
] | typescript | addEventListener: (listener) => { |
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.8212947249412537
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " const listener = createListener((val) => {\n clearTimeout(timeoutId);\n params.removeEventListener(listener);\n resolve(val);\n });\n params.addEventListener(listener);\n params.prepare?.();\n });\n}\nexport function handleCrxRpcRequest(",
"score": 0.8157286047935486
},
{
"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.802261471748352
},
{
"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.7938122749328613
},
{
"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.7769755125045776
}
] | typescript | (msg) => { |
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.8384170532226562
},
{
"filename": "src/kvs/kvs-filesystem.ts",
"retrieved_chunk": " await this.waitInit;\n const filePath = this._keyToFilePath(key);\n try {\n const val = await readFile(filePath, \"utf8\");\n return val;\n } catch (err) {\n return;\n }\n }\n async delete(key: K) {",
"score": 0.7643799781799316
},
{
"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.7576866745948792
},
{
"filename": "src/kvs/kvs-filesystem.ts",
"retrieved_chunk": " const baseDir = this.baseDir;\n const filePath = pathJoin(baseDir, this._keyToFilename(key));\n // console.log({ filePath });\n return filePath;\n }\n async set(key: K, value: V) {\n await this.waitInit;\n await writeFile(this._keyToFilePath(key), `${value}`);\n }\n async get(key: K): Promise<string | undefined> {",
"score": 0.7496668100357056
},
{
"filename": "src/openai.ts",
"retrieved_chunk": " }\n }\n throw err;\n }\n })();\n /* @ts-ignore */\n const stream = res.data as IncomingMessage;\n for await (const chunk of chunksToLines(stream)) {\n const data = JSON.parse(chunk);\n const content = data.choices[0].delta.content;",
"score": 0.7363798022270203
}
] | 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/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.7949299812316895
},
{
"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.784238338470459
},
{
"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.7837194204330444
},
{
"filename": "src/index.ts",
"retrieved_chunk": "import { executePrompt, executePromptStream } from \"./executePrompt.js\";\nimport { loadConfig } from \"./config.js\";\nimport { loadPromptConfig, listPrompts } from \"./loadPromptConfig.js\";\nimport { APPNAME } from \"./types.js\";\nimport FileSystemKVS from \"./kvs/kvs-filesystem.js\";\nimport { AppError } from \"./errors.js\";\nimport { readFileSync } from \"node:fs\";\nfunction parseArgs(argv: string[]) {\n const [_nodeBin, _jsFile, promptId, ...rest] = argv;\n const input = rest.join(\" \");",
"score": 0.7820338010787964
},
{
"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.7655741572380066
}
] | 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": " 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.8229708671569824
},
{
"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.8175835013389587
},
{
"filename": "src/config.ts",
"retrieved_chunk": " throw new ConfigError({\n message: `Please set the ${key} environment variable.`,\n });\n }\n return val;\n}\nconst paths = envPaths(APPNAME, { suffix: \"\" });\nexport function loadConfig(): Config {\n const config = {\n openai: {",
"score": 0.8169239163398743
},
{
"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.8107260465621948
},
{
"filename": "src/config.ts",
"retrieved_chunk": " apiKey: getEnvOrThrow(\"OPENAI_API_KEY\"),\n },\n paths: {\n data: pathJoin(homedir(), `.${APPNAME}`),\n cache: paths.cache,\n },\n useCache: true,\n };\n debug(config);\n return config;",
"score": 0.8043595552444458
}
] | typescript | config.openai.apiKey,
})
); |
import { executePrompt, executePromptStream } from "./executePrompt.js";
import { loadConfig } from "./config.js";
import { loadPromptConfig, listPrompts } from "./loadPromptConfig.js";
import { APPNAME } from "./types.js";
import FileSystemKVS from "./kvs/kvs-filesystem.js";
import { AppError } from "./errors.js";
import { readFileSync } from "node:fs";
function parseArgs(argv: string[]) {
const [_nodeBin, _jsFile, promptId, ...rest] = argv;
const input = rest.join(" ");
return { promptId, input };
}
function printUsageAndExit() {
console.log("Usage:");
console.log(`$ ${APPNAME} <promptType> <input>`);
console.log(`$ ${APPNAME} --list`);
console.log("");
console.log("Example: ");
console.log("");
console.log(`$ ${APPNAME} eli5 "what are large language models?"`);
process.exit(1);
}
function getInput(argvInput: string) {
try {
const stdinInput = readFileSync(process.stdin.fd, "utf-8");
// console.log({ stdinInput });
return `${argvInput} ${stdinInput}`;
} catch (err) {
return argvInput;
}
}
export async function cli() {
try {
const config = loadConfig();
const { promptId, input: argvInput } = parseArgs(process.argv);
if (promptId === "--list") {
const prompts = await listPrompts(config);
console.log(
prompts
.map((p) => {
const description = p.description ? `: ${p.description}` : "";
return `${p.name}${description}`;
})
.join("\n")
);
return;
} else if (promptId && promptId.startsWith("--")) {
printUsageAndExit();
}
const input = getInput(argvInput);
if (!promptId || !input) {
printUsageAndExit();
}
const promptConfig = await loadPromptConfig(promptId, config);
const cache = config.useCache
? | new FileSystemKVS({ baseDir: config.paths.cache })
: undefined; |
const stream = executePromptStream(promptConfig, input, config, cache);
for await (const chunk of stream) {
process.stdout.write(chunk);
}
process.stdout.write("\n");
} catch (err) {
if (err instanceof AppError) {
console.error(err.toString());
process.exit(err.exitCode);
}
console.error(err);
process.exit(1);
}
}
export default cli;
| src/index.ts | clevercli-clevercli-c660fae | [
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": " ]);\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.8329069018363953
},
{
"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.8202472925186157
},
{
"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.8145612478256226
},
{
"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.814338743686676
},
{
"filename": "src/loadPromptConfig.ts",
"retrieved_chunk": "export async function loadFromPath(path: string) {\n const promptConfig = await import(path);\n // TODO: validate promptConfig?\n return promptConfig.default;\n}\nexport async function loadPromptConfig(promptId: string, config: Config) {\n try {\n const promptConfig = await Promise.any([\n loadFromPath(sourceRelativePath(import.meta, `./prompts/${promptId}.js`)),\n loadFromPath(pathJoin(config.paths.data, `${promptId}.mjs`)),",
"score": 0.805510401725769
}
] | 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/messaging.ts",
"retrieved_chunk": " const listener = createListener((val) => {\n clearTimeout(timeoutId);\n params.removeEventListener(listener);\n resolve(val);\n });\n params.addEventListener(listener);\n params.prepare?.();\n });\n}\nexport function handleCrxRpcRequest(",
"score": 0.817551851272583
},
{
"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.81606125831604
},
{
"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.7986997365951538
},
{
"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.7914058566093445
},
{
"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.7773074507713318
}
] | 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.8482218980789185
},
{
"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.8111941814422607
},
{
"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.8012382388114929
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " const listener = createListener((val) => {\n clearTimeout(timeoutId);\n params.removeEventListener(listener);\n resolve(val);\n });\n params.addEventListener(listener);\n params.prepare?.();\n });\n}\nexport function handleCrxRpcRequest(",
"score": 0.7947981357574463
},
{
"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.7823140621185303
}
] | 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": "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.6948461532592773
},
{
"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.6814069747924805
},
{
"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.6680390238761902
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": "import { calcPubkey } from '../lib/nostr';\nconst LOCAL_STORAGE_KEY = {\n KEY_PAIR: 'KEY_PAIR',\n SIGN_POWER: 'SIGN_POWER',\n} as const;\nasync function get(key: string): Promise<any> {\n const { [key]: val } = await chrome.storage.local.get(key);\n return val;\n}\nasync function set(key: string, val: any): Promise<void> {",
"score": 0.6649198532104492
},
{
"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.6632295846939087
}
] | 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/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.8250032663345337
},
{
"filename": "src/content/index.ts",
"retrieved_chunk": " if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n if (msg.payload.kind === 'leaveChargeMode') {\n resolve();\n }\n },\n {\n addEventListener: (listener) => {",
"score": 0.8121365308761597
},
{
"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.8082863092422485
},
{
"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.7926976680755615
},
{
"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.7912805080413818
}
] | typescript | signed = await signEvent(keypair, payload.request); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = await getJoyconDevice();
await setupJoycon(joycon);
const | neutral = await getNextStrain(joycon); |
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " if (!device) {\n throw new Error('device not found.');\n }\n if (!device.opened) {\n await device.open();\n }\n await setupJoycon(device);\n return device;\n}\nexport async function setupJoycon(joycon: HIDDevice) {",
"score": 0.8282424807548523
},
{
"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.7480536103248596
},
{
"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.7299609184265137
},
{
"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.7272645235061646
},
{
"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.7250019907951355
}
] | typescript | neutral = await getNextStrain(joycon); |
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": "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.6975257992744446
},
{
"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.6874874830245972
},
{
"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.6739814877510071
},
{
"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.6667726635932922
},
{
"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.6653575301170349
}
] | typescript | await wait<HIDInputReportEvent, void>(
(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/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.8267014622688293
},
{
"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.8164258003234863
},
{
"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.8059498071670532
},
{
"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.7992894053459167
},
{
"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.7864573001861572
}
] | 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": " 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.8399279117584229
},
{
"filename": "src/lib/ring-con.ts",
"retrieved_chunk": " if (!device) {\n throw new Error('device not found.');\n }\n if (!device.opened) {\n await device.open();\n }\n await setupJoycon(device);\n return device;\n}\nexport async function setupJoycon(joycon: HIDDevice) {",
"score": 0.814934253692627
},
{
"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.8066514730453491
},
{
"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.7828041315078735
},
{
"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.7734602093696594
}
] | typescript | await setupJoycon(joycon); |
import { ext, generateMessageId, handleCrxRpcRequest, wait } from '../lib/messaging';
import { getJoyconDevice, getNextStrain, getStrain, setupJoycon } from '../lib/ring-con';
injectResourceScript('js/nip07-provider.js');
// 'nip07-provider' -> ...
window.addEventListener('message', async ({ data }: MessageEvent<CrxRpcRequestMessage>) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(data, 'content');
if (!shouldBeHandled) {
return;
}
if (next === 'background') {
// ... -> HERE -> 'background'
const response: CrxRpcResponseMessage = await chrome.runtime.sendMessage(data);
window.postMessage(response);
return;
} else if (!!next) {
console.warn('Unexpected message', data);
return;
}
//... -> HERE
switch (data.payload.kind) {
case 'enterChargeMode':
{
try {
const response = await enterChargeMode(data);
window.postMessage(response);
} catch (err) {
console.error(err);
window.postMessage({
ext,
messageId: data.messageId,
payload: {
kind: 'enterChargeMode',
response: false,
},
});
throw err;
}
}
break;
default:
break;
}
});
async function enterChargeMode({
messageId,
payload,
}: CrxRpcRequestMessage): Promise<CrxRpcResponseMessage> {
if (payload.kind !== 'enterChargeMode') {
throw 'Unexpected message';
}
const openChargeWindowReq: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['background'],
payload: {
kind: 'openChargeWindow',
request: {},
},
};
const { payload: result }: CrxRpcResponseMessage = await chrome.runtime.sendMessage(
openChargeWindowReq,
);
if (result.kind !== 'openChargeWindow') {
throw 'Unexpected message';
}
// Keep sending strain signals.
const joycon = | await getJoyconDevice(); |
await setupJoycon(joycon);
const neutral = await getNextStrain(joycon);
const sendStrain = (value: number) => {
const req: CrxRpcMessage = {
ext,
messageId: generateMessageId(),
src: 'content',
path: ['charge'],
payload: {
kind: 'sendStrain',
request: {
value,
neutral,
},
},
};
chrome.runtime.sendMessage(req);
};
const reportListener = (ev: HIDInputReportEvent) => {
const value = getStrain(ev);
if (value) {
sendStrain(value);
}
};
joycon.addEventListener('inputreport', reportListener);
// Wait for `leaveChargeMode` signal.
await wait<CrxRpcRequestMessage, void>(
(resolve) => (msg) => {
const { next, shouldBeHandled } = handleCrxRpcRequest(msg, 'content');
if (!shouldBeHandled) {
return;
}
if (!!next) {
console.warn('Unexpected message', msg);
return;
}
if (msg.payload.kind === 'leaveChargeMode') {
resolve();
}
},
{
addEventListener: (listener) => {
chrome.runtime.onMessage.addListener(listener);
},
removeEventListener: (listener) => {
chrome.runtime.onMessage.removeListener(listener);
},
},
);
// Stop sending strain signals.
joycon.removeEventListener('inputreport', reportListener);
return {
ext,
messageId,
payload: {
kind: 'enterChargeMode',
response: true,
},
};
}
function injectResourceScript(path: string) {
const script = document.createElement('script');
script.setAttribute('async', 'false');
script.setAttribute('type', 'text/javascript');
script.setAttribute('src', chrome.runtime.getURL(path));
document.head.appendChild(script);
}
| src/content/index.ts | penpenpng-nostronger-851a990 | [
{
"filename": "src/background/index.ts",
"retrieved_chunk": " if (next === 'content' && payload.kind === 'leaveChargeMode') {\n chrome.tabs.sendMessage(payload.request.senderTabId, msg);\n return;\n } else if (!!next) {\n console.warn('Unexpected message', msg);\n return;\n }\n const sendResponse = (val: any) => {\n const res: CrxRpcResponseMessage = {\n ...msg,",
"score": 0.8678346276283264
},
{
"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.809145450592041
},
{
"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.7978358268737793
},
{
"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.7870399951934814
},
{
"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.7829062938690186
}
] | 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/@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.8581353425979614
},
{
"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.8568196892738342
},
{
"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.8547336459159851
},
{
"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.8398312330245972
},
{
"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.8368780612945557
}
] | 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.8482218980789185
},
{
"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.8111941814422607
},
{
"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.8012382388114929
},
{
"filename": "src/lib/messaging.ts",
"retrieved_chunk": " const listener = createListener((val) => {\n clearTimeout(timeoutId);\n params.removeEventListener(listener);\n resolve(val);\n });\n params.addEventListener(listener);\n params.prepare?.();\n });\n}\nexport function handleCrxRpcRequest(",
"score": 0.7947981357574463
},
{
"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.7823140621185303
}
] | 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": "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.6944084167480469
},
{
"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.678351879119873
},
{
"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.6653065085411072
},
{
"filename": "src/lib/store.ts",
"retrieved_chunk": "import { calcPubkey } from '../lib/nostr';\nconst LOCAL_STORAGE_KEY = {\n KEY_PAIR: 'KEY_PAIR',\n SIGN_POWER: 'SIGN_POWER',\n} as const;\nasync function get(key: string): Promise<any> {\n const { [key]: val } = await chrome.storage.local.get(key);\n return val;\n}\nasync function set(key: string, val: any): Promise<void> {",
"score": 0.6625523567199707
},
{
"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.6623568534851074
}
] | typescript | resolve) => (event) => { |
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/SideMenu/index.tsx",
"retrieved_chunk": " >\n {link.title}\n </div>\n </SameTabLink>\n )}\n {showChildrenLinks[index] ? (\n <ExpandLessIcon\n htmlColor='white'\n sx={{ marginLeft: '-10px', paddingLeft: '1px' }}\n />",
"score": 0.8295656442642212
},
{
"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.8279934525489807
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " >\n {child.title}\n </div>\n </NewTabLinkDiv>\n ) : (\n <SameTabLink\n to={child.href as string}\n style={{\n display: 'flex',\n minHeight: '35px'",
"score": 0.8216395974159241
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " })}\n </List>\n </Collapse>\n <Divider />\n </List>\n ) : (\n <List sx={{ padding: '0px' }}>\n <ListItem\n button\n key={`linkChildren_${link.id}`}",
"score": 0.8142732977867126
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " paddingRight: '20px',\n marginRight: '4px',\n maxWidth: '100%',\n minHeight: '54px'\n }}\n key={`links_${link.id}`}\n onClick={() => toggleChildrenLinks(index)}\n >\n {link.external ? (\n <NewTabLinkDiv",
"score": 0.8136909008026123
}
] | typescript | : <Footer {...footer} />} |
import { UserPopup } from '../components/UserPopup';
import './storiesGlobals.css';
import { testUser } from './sampledata/SampleData';
import { Meta, StoryFn } from '@storybook/react';
import { User } from '../interfaces/index';
import { Dialog } from '../lib-components/Dialog';
import { useState } from 'react';
export default {
title: 'Components/UserPopup',
component: UserPopup,
argTypes: {
user: {
name: 'user',
control: 'object',
description: 'Object which defines user info'
},
logoutMethod: {
name: 'logoutMethod',
type: 'function',
description: 'Function which defines the lougout method for the page'
},
keycloak: {
name: 'keycloak',
description: 'Keycloak instance passed to UserPopup component',
control: { disable: true }
},
accountManagementUrl: {
name: 'accountManagementUrl',
description:
'Url that redirects to account management page of the system',
control: { disable: true }
}
}
} as Meta;
interface UserPopupStory {
user?: User;
}
const Template: StoryFn<UserPopupStory> = ({ user }) => {
const [visibility, setVisibility] = useState<boolean>(false);
return (
<>
<Dialog
type='information'
title='Logout Method '
children='This is a mocked logout. The logout method prop is a method that apply your custom logout to the system.'
acceptLabel='Understood'
visibility={visibility}
setVisibility={setVisibility}
/>
<UserPopup
logoutMethod={() => {
setVisibility(true);
}}
user={user}
auth={undefined}
accountManagementUrl='#'
/>
</>
);
};
export const UserPopup_ = Template.bind({});
UserPopup_.args = {
| user: testUser
}; | src/stories/UserPopup.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " </BrowserRouter>\n );\n};\nexport const SideMenu_ = Template.bind({});\nSideMenu_.args = {\n links: testLinks,\n top: '64px'\n};",
"score": 0.8476683497428894
},
{
"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.7929284572601318
},
{
"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.7877111434936523
},
{
"filename": "src/stories/SystemsPopup.stories.tsx",
"retrieved_chunk": " return <SystemsPopup systemsList={systemsList} />;\n};\nexport const SystemsList = Template.bind({});\nSystemsList.args = {\n systemsList: testSystems\n};",
"score": 0.7876653671264648
},
{
"filename": "src/lib-components/ForbiddenPage/index.tsx",
"retrieved_chunk": " pathname: string;\n };\n };\n}\nexport const ForbiddenPage = ({ auth }: ForbiddenPageProps) => {\n const email = auth?.user?.profile.email;\n const [from, setFrom] = useState<string>();\n const navigate = useNavigate();\n const location = useLocation() as Location;\n useEffect(() => {",
"score": 0.7801868915557861
}
] | typescript | user: testUser
}; |
|
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/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.834254264831543
},
{
"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.8233500719070435
},
{
"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.8148026466369629
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}\n type='text'\n value={searchString}\n onChange={handleSearch}\n />",
"score": 0.8074422478675842
},
{
"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.803601861000061
}
] | typescript | {imageSource ? imageSource : blankAvatar} |
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/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8604538440704346
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8463622331619263
},
{
"filename": "src/lib-components/ImageInput/index.tsx",
"retrieved_chunk": " }\n };\n }\n return (\n <div>\n <StyledFieldset\n onMouseEnter={() => setShowImageInput(true)}\n onMouseLeave={() => setShowImageInput(false)}\n >\n <StyledImage",
"score": 0.8423205614089966
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8385519981384277
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " onClose={handleUserClose}\n >\n <UserPopup user={profile} auth={auth} />\n </StyledUserMenu>\n </StyledToolbar>\n </StyledAppBar>\n </ParentNav>\n ) : (\n <ParentNav>\n <StyledAppBar>",
"score": 0.8270147442817688
}
] | 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/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.8431629538536072
},
{
"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.827640175819397
},
{
"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.8132760524749756
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " {haveSearchBar && (\n <SearchBarContainer>\n <Search>\n <StyledInputBase\n placeholder='Buscar…'\n inputProps={{ 'aria-label': 'search' }}\n type='text'\n value={searchString}\n onChange={handleSearch}\n />",
"score": 0.8096309900283813
},
{
"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.8087625503540039
}
] | typescript | StyledImage
src={imageSource ? imageSource : blankAvatar} |
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.9479115605354309
},
{
"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.8957040309906006
},
{
"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.857846736907959
},
{
"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.8577725887298584
},
{
"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.8529320359230042
}
] | typescript | sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
iconComponent: () => <></>
}; |
|
import { Meta, StoryFn } from '@storybook/react';
import ScopedCssBaseline from '@mui/material/ScopedCssBaseline/ScopedCssBaseline';
import './storiesGlobals.css';
import { Page } from '../lib-components/Page';
import { SideMenuLink, System, User } from '@/interfaces';
import { testLinks, testSystems, testUser } from './sampledata/SampleData';
import { BrowserRouter } from 'react-router-dom';
import EngineeringIcon from '@mui/icons-material/Engineering';
import { JSXElementConstructor } from 'react';
import { footerArgTypes, navbarArgTypes } from './utils/argTypes';
export default {
title: 'Components/Page',
parameters: {
docs: {
page: null
}
},
argTypes: {
navbar: {
table: {
disable: true
}
},
footer: {
table: {
disable: true
}
},
centralized: {
name: 'centralized',
type: { name: 'boolean', required: false },
description:
'Boolean which defines if the content of page is centralized or not.',
options: [true, false],
control: { type: 'boolean' }
},
...footerArgTypes,
...navbarArgTypes,
width: {
name: 'width',
type: { name: 'string', required: false },
description: "String wich defines children's width",
control: { type: 'text' },
table: {
category: 'Children'
}
},
height: {
name: 'height',
type: { name: 'string', required: false },
description: "String wich defines children's height",
control: { type: 'text' },
table: {
category: 'Children'
}
},
color: {
name: 'color',
type: { name: 'string', required: false },
description: "String wich defines children's color",
control: { type: 'color' },
table: {
category: 'Children'
}
}
}
} as Meta;
interface StoryPageProps {
isLandingPage: boolean;
haveSearchBar: boolean;
hiddenUser: boolean;
user: User;
h1: boolean;
sideMenuLinks: SideMenuLink[];
systemsListPopup: boolean;
systemsList: System[];
IconComponent: JSXElementConstructor<any>;
title: string;
footerTitle: string;
footerTelephone: string;
footerTelephoneComplement: string;
footerEmail: string;
footerLink: string;
footerTextLink: string;
footerDescription: string;
footerCopyrightText: string;
width: string;
height: string;
color: string;
centralized: boolean;
}
interface IconComponentProps {
haveIcon: JSXElementConstructor<any>;
}
const IconComponent = ({ haveIcon }: IconComponentProps) => {
if (!haveIcon) {
return <></>;
} else {
return <EngineeringIcon />;
}
};
const Template: StoryFn<StoryPageProps> = (args) => {
return (
<ScopedCssBaseline>
<BrowserRouter>
| <Page
navbar={{ |
isLandingPage: args.isLandingPage,
haveSearchBar: args.haveSearchBar ? true : false,
hiddenUser: args.hiddenUser,
user: args.hiddenUser ? undefined : args.user,
h1: args.h1,
children: undefined,
title: args.title,
sideMenuLinks: args.sideMenuLinks,
systemsList: args.systemsList ? args.systemsList : undefined,
IconComponent
}}
footer={{
title: args.footerTitle,
telephone: args.footerTelephone,
telephoneComplement: args.footerTelephoneComplement,
email: args.footerEmail,
link: args.footerLink,
textLink: args.footerTextLink,
description: args.footerDescription,
copyrightText: args.footerCopyrightText
}}
centralized={args.centralized}
createNavbarContext={false}
>
<div
style={{
width: `${args.width}`,
height: `${args.height}`,
color: `${args.color}`,
backgroundColor: `${args.color}`,
padding: '20px 40px'
}}
></div>
</Page>
</BrowserRouter>
</ScopedCssBaseline>
);
};
export const Page_ = Template.bind({});
Page_.args = {
width: '150px',
height: '150px',
color: '#000000',
title: 'Cinnamon',
h1: true,
isLandingPage: false,
haveSearchBar: true,
hiddenUser: false,
user: testUser,
sideMenuLinks: testLinks,
systemsListPopup: false,
systemsList: testSystems,
footerTitle: 'FOOTER TITLE',
footerTelephone: '(xx) xxxx-xxxx',
footerTelephoneComplement: 'Internal number: xxxx / xxxx',
footerEmail: '[email protected]',
footerLink: 'https://www.google.com',
footerTextLink: 'Site',
footerDescription: "Footer's description with \n line break",
footerCopyrightText: 'CIn UFPE | All rights reserved'
};
| src/stories/Page.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/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.9244321584701538
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8824844360351562
},
{
"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.8810840845108032
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8790531158447266
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " return <Maintenance />;\n }\n}\nexport const ErrorScreen = (props: ErrorScreenProps) => {\n const { errorType } = props;\n return <>{errorMapping(errorType)}</>;\n};\nconst NotFound = () => {\n return (\n <NotFoundWrapper>",
"score": 0.8788821697235107
}
] | typescript | <Page
navbar={{ |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map( | (child) => { |
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </>\n ) : (\n <>\n <StyledAccordion\n disabled\n key={`positions_${position.id}`}\n >\n <AccordionSummary\n expandIcon={<ExpandMoreIcon />}\n aria-controls='panel3a-content'",
"score": 0.8001272678375244
},
{
"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.7922911047935486
},
{
"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.7889053821563721
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " aria-haspopup='true'\n onClick={handleSystemsMenu}\n color='inherit'\n >\n <SystemsButton>\n <img src={systemsMenuIcon} alt='Systems Menu' />\n </SystemsButton>\n </IconButton>\n <StyledSystemMenu\n id='menu-appbar'",
"score": 0.7784935235977173
},
{
"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.7775776386260986
}
] | typescript | (child) => { |
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
< | HeaderBar color={color[type]} />
<Title>{title}</Title>
</div>
); |
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
<StyledDialog
onClose={onHide}
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8400923609733582
},
{
"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.8399699330329895
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }, [navbarContextClass]);\n return (\n <NavbarContext.Provider value={navbarContextClass}>\n <div ref={navbarRef} style={{ display: 'inline' }}>\n {components?.navbar ? components.navbar : <Navbar {...navbar} />}\n </div>\n <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>\n <MainDiv\n style={{\n minHeight: `calc(100vh - ${diff}px)`,",
"score": 0.8316881656646729
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8316380977630615
},
{
"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.8217628598213196
}
] | 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/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.8535980582237244
},
{
"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.8526729345321655
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " </Button>\n <Button\n onClick={acceptFunction}\n style={{\n marginLeft: 10,\n backgroundColor: color[type],\n color: '#ffffff'\n }}\n >\n {acceptLabel}",
"score": 0.8503144383430481
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " IconComponent={IconComponent}\n />\n </LeftContainer>\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>\n )}\n </TitleContainer>",
"score": 0.8446967005729675
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />\n </a>\n )}\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>",
"score": 0.8358112573623657
}
] | 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": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8704802989959717
},
{
"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.8609415888786316
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8383873105049133
},
{
"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.8286629915237427
},
{
"filename": "src/lib-components/ImageInput/index.tsx",
"retrieved_chunk": " }\n };\n }\n return (\n <div>\n <StyledFieldset\n onMouseEnter={() => setShowImageInput(true)}\n onMouseLeave={() => setShowImageInput(false)}\n >\n <StyledImage",
"score": 0.8286013603210449
}
] | typescript | StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list} |
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/UserPopup/index.tsx",
"retrieved_chunk": " </>\n ) : (\n <>\n <StyledAccordion\n disabled\n key={`positions_${position.id}`}\n >\n <AccordionSummary\n expandIcon={<ExpandMoreIcon />}\n aria-controls='panel3a-content'",
"score": 0.8032944202423096
},
{
"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.7989176511764526
},
{
"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.7950702905654907
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " aria-haspopup='true'\n onClick={handleSystemsMenu}\n color='inherit'\n >\n <SystemsButton>\n <img src={systemsMenuIcon} alt='Systems Menu' />\n </SystemsButton>\n </IconButton>\n <StyledSystemMenu\n id='menu-appbar'",
"score": 0.7843453884124756
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorUserEl)}\n onClose={handleUserClose}\n >\n <UserPopup\n user={profile}\n auth={auth}\n accountManagementUrl={accountManagementUrl}\n />\n </StyledUserMenu>\n </RightContainer>",
"score": 0.7809827923774719
}
] | 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/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.8582911491394043
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorSystemsEl)}\n onClose={handleSystemsClose}\n >\n <SystemsPopup systemsList={systemsList} />\n </StyledSystemMenu>\n </>\n )}\n {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />",
"score": 0.8269166350364685
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8244851231575012
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " onClose={handleUserClose}\n >\n <UserPopup user={profile} auth={auth} />\n </StyledUserMenu>\n </StyledToolbar>\n </StyledAppBar>\n </ParentNav>\n ) : (\n <ParentNav>\n <StyledAppBar>",
"score": 0.8201872110366821
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </PositionsContainer>\n )}\n <LogoutButton\n variant='text'\n type='button'\n onClick={() => {\n logoutFunction();\n }}\n >\n Sair",
"score": 0.8198626041412354
}
] | typescript | SameTabLink
to={link.href as string} |
import { useEffect, useState } from 'react';
import { StyledFieldset, StyledImage, StyledLabel, StyledSpan } from './styles';
import blankAvatar from '../../assets/default-profile-picture.jpg';
export interface ImageInputProps {
required?: boolean;
disabled?: boolean;
id: string;
file?: File;
setFile: React.Dispatch<React.SetStateAction<File>>;
}
export const ImageInput = ({
required = false,
disabled = false,
id,
file,
setFile
}: ImageInputProps) => {
const [imageSource, setImageSource] = useState<null | string | ArrayBuffer>(
null
);
const [showImageInput, setShowImageInput] = useState<boolean>(false);
useEffect(() => {
if (file) {
getImageSource(file);
}
}, []);
function getImage(e: React.ChangeEvent<HTMLInputElement>) {
if (e.target.files) {
const file = e.target.files[0];
setFile(file);
getImageSource(file);
setShowImageInput(false);
}
}
function getImageSource(file: File) {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = () => {
if (reader.result) {
setImageSource(reader.result);
}
};
}
return (
<div>
| <StyledFieldset
onMouseEnter={() => setShowImageInput(true)} |
onMouseLeave={() => setShowImageInput(false)}
>
<StyledImage
src={imageSource ? imageSource : blankAvatar}
alt='User Picture'
/>
<input
type='file'
accept='.jpg, .jpeg, .png'
required={required}
disabled={disabled}
style={{ display: 'none' }}
id={id}
onChange={getImage}
/>
{showImageInput && (
<StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)}
</StyledFieldset>
</div>
);
};
| src/lib-components/ImageInput/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " })\n );\n }\n }\n const toggleDrawer = () => {\n setVisibility(!visibility);\n };\n const list = (\n <ListWrapper\n style={{",
"score": 0.842055082321167
},
{
"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.8361043930053711
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8280166387557983
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": "}: NewTabLinkDivProps) {\n useEffect(() => {\n if (!link && !child) {\n throw new Error('No child or link passed to newTabLinkDiv component');\n }\n }, []);\n if (link) {\n return (\n <NewTabLink\n style={{ minHeight: '54px' }}",
"score": 0.8257470726966858
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " }, [auth.isLoading]);\n if (auth.isLoading) {\n if (waiting) {\n setTimeout(() => {\n setWaiting(false);\n }, 6000);\n return (\n <Box\n minHeight='100vh'\n display='flex'",
"score": 0.8181703090667725
}
] | typescript | <StyledFieldset
onMouseEnter={() => setShowImageInput(true)} |
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.8330281972885132
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8283792734146118
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8197615146636963
},
{
"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.8114029169082642
},
{
"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.8083207607269287
}
] | typescript | ToastContainer
toastProps={{ |
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/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.9205993413925171
},
{
"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.9037680625915527
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " return <Maintenance />;\n }\n}\nexport const ErrorScreen = (props: ErrorScreenProps) => {\n const { errorType } = props;\n return <>{errorMapping(errorType)}</>;\n};\nconst NotFound = () => {\n return (\n <NotFoundWrapper>",
"score": 0.8889976739883423
},
{
"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.8859902620315552
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8801742196083069
}
] | typescript | <Navbar
isLandingPage={args.isLandingPage} |
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/Navbar/index.tsx",
"retrieved_chunk": " {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />\n </a>\n )}\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>",
"score": 0.8539513349533081
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " IconComponent={IconComponent}\n />\n </LeftContainer>\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>\n )}\n </TitleContainer>",
"score": 0.848426103591919
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " <Button\n onClick={onHide}\n style={{ backgroundColor: color[type], color: '#ffffff' }}\n >\n {acceptLabel}\n </Button>\n ) : (\n <div>\n <Button onClick={rejectFunction} style={{ color: color[type] }}>\n {rejectLabel}",
"score": 0.8399571180343628
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " sx={{\n padding: '0px'\n }}\n >\n {link.external ? (\n <NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>\n <NewTabLinkWithoutChild link={link} />\n </NewTabLinkDiv>\n ) : (\n <SameTabLink",
"score": 0.8301730751991272
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorSystemsEl)}\n onClose={handleSystemsClose}\n >\n <SystemsPopup systemsList={systemsList} />\n </StyledSystemMenu>\n </>\n )}\n {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />",
"score": 0.8291276693344116
}
] | typescript | StyledLabel htmlFor={id}>
<StyledSpan>Escolha uma imagem</StyledSpan>
</StyledLabel>
)} |
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": " 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.8835694789886475
},
{
"filename": "src/components/HamburgerButton/styles.ts",
"retrieved_chunk": " top: -20%;\n }\n `;\n }\n }}\n }\n ${(props) => {\n if (props.isOpen) {\n return css`\n ${HambBottom} {",
"score": 0.8638296723365784
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " state={{ from: location }}\n />\n );\n }\n setTimeout(() => auth.signinRedirect(), 500);\n return (\n <Box\n minHeight='100vh'\n display='flex'\n alignItems='center'",
"score": 0.8534603118896484
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " return <Maintenance />;\n }\n}\nexport const ErrorScreen = (props: ErrorScreenProps) => {\n const { errorType } = props;\n return <>{errorMapping(errorType)}</>;\n};\nconst NotFound = () => {\n return (\n <NotFoundWrapper>",
"score": 0.8501768112182617
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8217343091964722
}
] | typescript | <ListWrapper
style={{ |
import { useEffect, useState } from 'react';
import { StyledDrawer, ListWrapper, SameTabLink, NewTabLink } from './styles';
import ExpandLessIcon from '@mui/icons-material/ExpandLess';
import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
import itemBulletIcon from '../../assets/icons/item_bullet.svg';
import {
ScopedCssBaseline,
List,
Divider,
ListItem,
ListItemIcon,
Collapse
} from '@mui/material';
import { useLocation } from 'react-router-dom';
import { SideMenuLink, Link } from '../../interfaces/index';
export interface SideMenuProps {
links: SideMenuLink[];
top: string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
}
interface NewTabLinkDivProps {
link?: SideMenuLink;
toggleDrawer: (() => void) | undefined;
child?: Link;
children: JSX.Element | JSX.Element[];
}
function SideMenuIcon({ iconUrl, title, IconComponent }: any) {
return (
<ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>
{iconUrl && <img src={iconUrl} alt={`${title} icon`} />}
{IconComponent && <IconComponent />}
</ListItemIcon>
);
}
function NewTabLinkWithoutChild(props: { link: SideMenuLink }) {
const { link } = props;
return (
<>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</>
);
}
function NewTabLinkDiv({
link,
toggleDrawer,
child,
children
}: NewTabLinkDivProps) {
useEffect(() => {
if (!link && !child) {
throw new Error('No child or link passed to newTabLinkDiv component');
}
}, []);
if (link) {
return (
<NewTabLink
style={{ minHeight: '54px' }}
href={link.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
{children}
</NewTabLink>
);
} else if (child) {
return (
<NewTabLink
style={{
minHeight: '35px'
}}
href={child.href as string}
target='_blank'
rel='noopener noreferrer'
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLink>
);
} else {
return <></>;
}
}
export function SideMenu({
links,
top,
visibility = false,
setVisibility
}: SideMenuProps) {
const [showChildrenLinks, setShowChildrenLinks] = useState<boolean[]>([]);
const { pathname } = useLocation();
useEffect(() => {
window.scrollTo(0, 0);
}, [pathname]);
useEffect(() => {
if (links && links.length > 0) {
setShowChildrenLinks(links.map(() => false));
}
}, []);
function toggleChildrenLinks(index: number) {
if (!showChildrenLinks[index]) {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return true;
} else {
return value;
}
})
);
} else {
setShowChildrenLinks(
showChildrenLinks.map((value, index_map) => {
if (index_map === index) {
return false;
} else {
return value;
}
})
);
}
}
const toggleDrawer = () => {
setVisibility(!visibility);
};
const list = (
<ListWrapper
style={{
paddingTop: '15px',
paddingBottom: '15px'
}}
>
{links.map((link, index) => {
return (
<div key={`link_${link.id}`}>
{link.children !== undefined && link.children.length > 0 ? (
<List
sx={{
display: 'flex',
padding: '0px',
flexDirection: 'column'
}}
>
<ListItem
button
sx={{
display: 'flex',
padding: '0px',
paddingRight: '20px',
marginRight: '4px',
maxWidth: '100%',
minHeight: '54px'
}}
key={`links_${link.id}`}
onClick={() => toggleChildrenLinks(index)}
>
{link.external ? (
<NewTabLinkDiv
link={link}
toggleDrawer={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
| <SameTabLink
to={link.href as string} |
style={{
minHeight: '54px',
display: 'flex',
justifyContent: 'center',
justifyItems: 'center'
}}
onClick={
showChildrenLinks.length ? undefined : toggleDrawer
}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '78%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
{showChildrenLinks[index] ? (
<ExpandLessIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
) : (
<ExpandMoreIcon
htmlColor='white'
sx={{ marginLeft: '-10px', paddingLeft: '1px' }}
/>
)}
<Divider />
</ListItem>
<Collapse
in={showChildrenLinks[index]}
timeout='auto'
unmountOnExit
>
<List component='div' disablePadding>
{link.children.map((child) => {
return (
<ListItem
button
key={`linkChild_${child.id}`}
sx={{
display: 'flex',
minWidth: '100%',
padding: '0px'
}}
>
{child.external ? (
<NewTabLinkDiv
child={child}
toggleDrawer={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</NewTabLinkDiv>
) : (
<SameTabLink
to={child.href as string}
style={{
display: 'flex',
minHeight: '35px'
}}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
minHeight: '100%',
overflow: 'clip',
flexWrap: 'nowrap'
}}
>
<img
src={itemBulletIcon}
alt={`${child.title} Icon`}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{child.title}
</div>
</SameTabLink>
)}
</ListItem>
);
})}
</List>
</Collapse>
<Divider />
</List>
) : (
<List sx={{ padding: '0px' }}>
<ListItem
button
key={`linkChildren_${link.id}`}
sx={{
padding: '0px'
}}
>
{link.external ? (
<NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>
<NewTabLinkWithoutChild link={link} />
</NewTabLinkDiv>
) : (
<SameTabLink
to={link.href as string}
style={{ minHeight: '54px' }}
onClick={toggleDrawer}
>
<div
style={{
display: 'flex',
justifyContent: 'center',
justifyItems: 'center',
maxWidth: '20%'
}}
>
<SideMenuIcon
iconUrl={link.iconUrl}
title={link.iconUrl}
IconComponent={link.IconComponent}
/>
</div>
<div
style={{
display: 'flex',
justifyContent: 'left',
minWidth: '80%'
}}
>
{link.title}
</div>
</SameTabLink>
)}
</ListItem>
<Divider />
</List>
)}
</div>
);
})}
</ListWrapper>
);
return (
<div>
<ScopedCssBaseline>
<StyledDrawer top={top} open={visibility} onClose={toggleDrawer}>
{list}
</StyledDrawer>
</ScopedCssBaseline>
</div>
);
}
| src/components/SideMenu/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/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.8709579706192017
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorSystemsEl)}\n onClose={handleSystemsClose}\n >\n <SystemsPopup systemsList={systemsList} />\n </StyledSystemMenu>\n </>\n )}\n {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />",
"score": 0.8299689292907715
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8234224319458008
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorUserEl)}\n onClose={handleUserClose}\n >\n <UserPopup\n user={profile}\n auth={auth}\n accountManagementUrl={accountManagementUrl}\n />\n </StyledUserMenu>\n </RightContainer>",
"score": 0.8205956816673279
},
{
"filename": "src/components/UserPopup/index.tsx",
"retrieved_chunk": " </PositionsContainer>\n )}\n <LogoutButton\n variant='text'\n type='button'\n onClick={() => {\n logoutFunction();\n }}\n >\n Sair",
"score": 0.8199727535247803
}
] | typescript | <SameTabLink
to={link.href as string} |
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/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.85926353931427
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8541724681854248
},
{
"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.840932309627533
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " paddingTop: '15px',\n paddingBottom: '15px'\n }}\n >\n {links.map((link, index) => {\n return (\n <div key={`link_${link.id}`}>\n {link.children !== undefined && link.children.length > 0 ? (\n <List\n sx={{",
"score": 0.8371971845626831
},
{
"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.8194937705993652
}
] | 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": " 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.876630425453186
},
{
"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.8595002889633179
},
{
"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.8563855886459351
},
{
"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.8550270795822144
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " </Button>\n <Button\n onClick={acceptFunction}\n style={{\n marginLeft: 10,\n backgroundColor: color[type],\n color: '#ffffff'\n }}\n >\n {acceptLabel}",
"score": 0.8546143770217896
}
] | typescript | <img src={itemBulletIcon} alt={`${child.title} Icon`} />
</div>
<div
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.9403678774833679
},
{
"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.8791683316230774
},
{
"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.8722285032272339
},
{
"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.8666360378265381
},
{
"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.8488647937774658
}
] | typescript | testSystems,
iconComponent: () => <></>
}; |
|
import {
useTheme,
Button,
DialogTitle,
DialogContent,
DialogActions,
ScopedCssBaseline
} from '@mui/material';
import { StyledDialog, Title, HeaderBar } from './styles';
export interface DialogProps {
type: 'information' | 'alert' | 'decision' | 'confirmation' | 'error';
title: string;
children: JSX.Element | string;
visibility?: boolean;
setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
acceptLabel?: string;
rejectLabel?: string;
acceptFunction?: () => void;
rejectFunction?: () => void;
}
export const Dialog = ({
type,
title,
children,
visibility = false,
setVisibility,
acceptLabel = 'Ok',
rejectLabel = 'Cancelar',
acceptFunction,
rejectFunction
}: DialogProps) => {
const theme = useTheme();
const color = {
information: theme.palette.secondary.main,
alert: theme.palette.warning.main,
decision: theme.palette.info.dark,
confirmation: theme.palette.success.main,
error: theme.palette.error.main
};
function onHide() {
setVisibility(!visibility);
}
const header = (
<div>
<HeaderBar color={color[type]} />
| <Title>{title}</Title>
</div>
); |
const dialogFooter =
type === 'information' || type === 'alert' ? (
<Button
onClick={onHide}
style={{ backgroundColor: color[type], color: '#ffffff' }}
>
{acceptLabel}
</Button>
) : (
<div>
<Button onClick={rejectFunction} style={{ color: color[type] }}>
{rejectLabel}
</Button>
<Button
onClick={acceptFunction}
style={{
marginLeft: 10,
backgroundColor: color[type],
color: '#ffffff'
}}
>
{acceptLabel}
</Button>
</div>
);
return (
<div>
<StyledDialog
onClose={onHide}
aria-labelledby='customized-dialog-title'
open={visibility}
sx={{ maxWidth: '100vw' }}
>
<ScopedCssBaseline>
<DialogTitle id='customized-dialog-title'>{header}</DialogTitle>
<DialogContent>{children}</DialogContent>
<DialogActions>{dialogFooter}</DialogActions>
</ScopedCssBaseline>
</StyledDialog>
</div>
);
};
| src/lib-components/Dialog/index.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8384367227554321
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }, [navbarContextClass]);\n return (\n <NavbarContext.Provider value={navbarContextClass}>\n <div ref={navbarRef} style={{ display: 'inline' }}>\n {components?.navbar ? components.navbar : <Navbar {...navbar} />}\n </div>\n <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>\n <MainDiv\n style={{\n minHeight: `calc(100vh - ${diff}px)`,",
"score": 0.8260234594345093
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.823081910610199
},
{
"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.8201746940612793
},
{
"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.8195071220397949
}
] | 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.8461768627166748
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " }\n }\n if (auth.isAuthenticated && haveAccess) {\n return children;\n }\n if (auth.isAuthenticated) {\n return (\n <Navigate\n to={`${process.env.PUBLIC_URL}/forbidden`}\n replace",
"score": 0.8279006481170654
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " state={{ from: location }}\n />\n );\n }\n setTimeout(() => auth.signinRedirect(), 500);\n return (\n <Box\n minHeight='100vh'\n display='flex'\n alignItems='center'",
"score": 0.7992931604385376
},
{
"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.7823233604431152
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.7790242433547974
}
] | typescript | ={forbidden_403} |
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/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.8739392757415771
},
{
"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.8554413318634033
},
{
"filename": "src/stories/SystemsPopup.stories.tsx",
"retrieved_chunk": " return <SystemsPopup systemsList={systemsList} />;\n};\nexport const SystemsList = Template.bind({});\nSystemsList.args = {\n systemsList: testSystems\n};",
"score": 0.7873302102088928
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {link.title}\n </div>\n </>\n );\n}\nfunction NewTabLinkDiv({\n link,\n toggleDrawer,\n child,\n children",
"score": 0.785811185836792
},
{
"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.7839920520782471
}
] | 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/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8384367227554321
},
{
"filename": "src/lib-components/Page/index.tsx",
"retrieved_chunk": " }, [navbarContextClass]);\n return (\n <NavbarContext.Provider value={navbarContextClass}>\n <div ref={navbarRef} style={{ display: 'inline' }}>\n {components?.navbar ? components.navbar : <Navbar {...navbar} />}\n </div>\n <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>\n <MainDiv\n style={{\n minHeight: `calc(100vh - ${diff}px)`,",
"score": 0.8260234594345093
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.823081910610199
},
{
"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.8201746940612793
},
{
"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.8195071220397949
}
] | 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/stories/Page.stories.tsx",
"retrieved_chunk": "}\ninterface IconComponentProps {\n haveIcon: JSXElementConstructor<any>;\n}\nconst IconComponent = ({ haveIcon }: IconComponentProps) => {\n if (!haveIcon) {\n return <></>;\n } else {\n return <EngineeringIcon />;\n }",
"score": 0.8550287485122681
},
{
"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.8472276926040649
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " return <Maintenance />;\n }\n}\nexport const ErrorScreen = (props: ErrorScreenProps) => {\n const { errorType } = props;\n return <>{errorMapping(errorType)}</>;\n};\nconst NotFound = () => {\n return (\n <NotFoundWrapper>",
"score": 0.8415207862854004
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": "}\nexport const RequireAuth = (props: AuthProps): React.ReactElement => {\n const location = useLocation();\n const { children, auth, permittedRoles } = props;\n const [waiting, setWaiting] = useState(true);\n let haveAccess = false;\n useEffect(() => {\n if (auth.isLoading && !waiting) {\n setWaiting(true);\n }",
"score": 0.8398379683494568
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " state={{ from: location }}\n />\n );\n }\n setTimeout(() => auth.signinRedirect(), 500);\n return (\n <Box\n minHeight='100vh'\n display='flex'\n alignItems='center'",
"score": 0.8321266770362854
}
] | typescript | <NewTabLink
style={{ minHeight: '54px' }} |
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/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8514028191566467
},
{
"filename": "src/lib-components/ImageInput/index.tsx",
"retrieved_chunk": " }\n };\n }\n return (\n <div>\n <StyledFieldset\n onMouseEnter={() => setShowImageInput(true)}\n onMouseLeave={() => setShowImageInput(false)}\n >\n <StyledImage",
"score": 0.8401699066162109
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8366217613220215
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8348524570465088
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " onClose={handleUserClose}\n >\n <UserPopup user={profile} auth={auth} />\n </StyledUserMenu>\n </StyledToolbar>\n </StyledAppBar>\n </ParentNav>\n ) : (\n <ParentNav>\n <StyledAppBar>",
"score": 0.8229571580886841
}
] | typescript | StyledDialog
onClose={onHide} |
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": " 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.8836671113967896
},
{
"filename": "src/components/HamburgerButton/styles.ts",
"retrieved_chunk": " top: -20%;\n }\n `;\n }\n }}\n }\n ${(props) => {\n if (props.isOpen) {\n return css`\n ${HambBottom} {",
"score": 0.861833930015564
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " return <Maintenance />;\n }\n}\nexport const ErrorScreen = (props: ErrorScreenProps) => {\n const { errorType } = props;\n return <>{errorMapping(errorType)}</>;\n};\nconst NotFound = () => {\n return (\n <NotFoundWrapper>",
"score": 0.8481091856956482
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " state={{ from: location }}\n />\n );\n }\n setTimeout(() => auth.signinRedirect(), 500);\n return (\n <Box\n minHeight='100vh'\n display='flex'\n alignItems='center'",
"score": 0.8477222323417664
},
{
"filename": "src/lib-components/RequireAuth/index.tsx",
"retrieved_chunk": " alignItems='center'\n justifyContent='center'\n >\n <CircularProgress />\n </Box>\n );\n }\n return (\n <Box\n minHeight='100vh'",
"score": 0.8284784555435181
}
] | 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/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.8500417470932007
},
{
"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.8279963731765747
},
{
"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.817730188369751
},
{
"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.8170754909515381
},
{
"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.8163948655128479
}
] | typescript | <StyledImage
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/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.8434985280036926
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8279169797897339
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": "}\ninterface NewTabLinkDivProps {\n link?: SideMenuLink;\n toggleDrawer: (() => void) | undefined;\n child?: Link;\n children: JSX.Element | JSX.Element[];\n}\nfunction SideMenuIcon({ iconUrl, title, IconComponent }: any) {\n return (\n <ListItemIcon sx={{ color: 'white', justifyContent: 'center' }}>",
"score": 0.8173329830169678
},
{
"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.8147441148757935
},
{
"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.8135684728622437
}
] | typescript | {components?.navbar ? components.navbar : <Navbar {...navbar} />} |
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/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.8500417470932007
},
{
"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.8279963731765747
},
{
"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.817730188369751
},
{
"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.8170754909515381
},
{
"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.8163948655128479
}
] | typescript | 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/Navbar/index.tsx",
"retrieved_chunk": " {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />\n </a>\n )}\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>",
"score": 0.8552347421646118
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " IconComponent={IconComponent}\n />\n </LeftContainer>\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>\n )}\n </TitleContainer>",
"score": 0.850081205368042
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " <Button\n onClick={onHide}\n style={{ backgroundColor: color[type], color: '#ffffff' }}\n >\n {acceptLabel}\n </Button>\n ) : (\n <div>\n <Button onClick={rejectFunction} style={{ color: color[type] }}>\n {rejectLabel}",
"score": 0.839424729347229
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " sx={{\n padding: '0px'\n }}\n >\n {link.external ? (\n <NewTabLinkDiv link={link} toggleDrawer={toggleDrawer}>\n <NewTabLinkWithoutChild link={link} />\n </NewTabLinkDiv>\n ) : (\n <SameTabLink",
"score": 0.8316468000411987
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorSystemsEl)}\n onClose={handleSystemsClose}\n >\n <SystemsPopup systemsList={systemsList} />\n </StyledSystemMenu>\n </>\n )}\n {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />",
"score": 0.8282762765884399
}
] | typescript | 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/components/SideMenu/index.tsx",
"retrieved_chunk": " >\n {link.title}\n </div>\n </SameTabLink>\n )}\n {showChildrenLinks[index] ? (\n <ExpandLessIcon\n htmlColor='white'\n sx={{ marginLeft: '-10px', paddingLeft: '1px' }}\n />",
"score": 0.8302101492881775
},
{
"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.8261568546295166
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " >\n {child.title}\n </div>\n </NewTabLinkDiv>\n ) : (\n <SameTabLink\n to={child.href as string}\n style={{\n display: 'flex',\n minHeight: '35px'",
"score": 0.8215518593788147
},
{
"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.8153207302093506
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " })}\n </List>\n </Collapse>\n <Divider />\n </List>\n ) : (\n <List sx={{ padding: '0px' }}>\n <ListItem\n button\n key={`linkChildren_${link.id}`}",
"score": 0.8150805234909058
}
] | 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/lib-components/Navbar/index.tsx",
"retrieved_chunk": " {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />\n </a>\n )}\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>",
"score": 0.8567562103271484
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " <Button\n onClick={onHide}\n style={{ backgroundColor: color[type], color: '#ffffff' }}\n >\n {acceptLabel}\n </Button>\n ) : (\n <div>\n <Button onClick={rejectFunction} style={{ color: color[type] }}>\n {rejectLabel}",
"score": 0.8511468172073364
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " IconComponent={IconComponent}\n />\n </LeftContainer>\n <TitleContainer>\n {h1 ? (\n <span style={{ fontSize: '2em' }}>{title}</span>\n ) : (\n <span style={{ fontSize: '1.5em' }}>{title}</span>\n )}\n </TitleContainer>",
"score": 0.8467141389846802
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " open={Boolean(anchorSystemsEl)}\n onClose={handleSystemsClose}\n >\n <SystemsPopup systemsList={systemsList} />\n </StyledSystemMenu>\n </>\n )}\n {logoSrc && (\n <a href={logoRedirectUrl}>\n <Logo src={logoSrc} alt='Logo da Instituição' />",
"score": 0.8300058245658875
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " >\n {link.title}\n </div>\n </SameTabLink>\n )}\n {showChildrenLinks[index] ? (\n <ExpandLessIcon\n htmlColor='white'\n sx={{ marginLeft: '-10px', paddingLeft: '1px' }}\n />",
"score": 0.8209459781646729
}
] | 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": " 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.7878762483596802
},
{
"filename": "src/stories/Page.stories.tsx",
"retrieved_chunk": " user: args.hiddenUser ? undefined : args.user,\n h1: args.h1,\n children: undefined,\n title: args.title,\n sideMenuLinks: args.sideMenuLinks,\n systemsList: args.systemsList ? args.systemsList : undefined,\n IconComponent\n }}\n footer={{\n title: args.footerTitle,",
"score": 0.7620702981948853
},
{
"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.7467631697654724
},
{
"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.7351698875427246
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " setSearchString(e.target.value);\n searchFunction(e.target.value);\n }\n function handleToggleSideMenu() {\n setSideMenuIsOpen(!sideMenuIsOpen);\n }\n systemsList = auth\n ? systemsList.filter((system) => {\n if (system.visibleRole && hasAccess(auth, [system.visibleRole])) {\n return system;",
"score": 0.7201876640319824
}
] | typescript | this.children = navbarProps.children; |
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.9635033011436462
},
{
"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.9104289412498474
},
{
"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.9075117111206055
},
{
"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.8979301452636719
},
{
"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.8870956897735596
}
] | typescript | qb,
columnsToInsert,
this.transforms,
this.returnColumns
); |
import { Insertable, Selectable, Selection, Updateable } from 'kysely';
import {
SelectableColumnTuple,
SelectedRow,
SelectionColumn,
} from '../lib/type-utils';
import { TableMapperTransforms } from './table-mapper-transforms';
import { AbstractTableMapper } from './abstract-table-mapper';
/**
* Table mapper that defaults to passing through all query inputs and output
* unchanged, allowing the selective overloading of transforms.
* @typeParam DB Interface whose fields are table names defining tables.
* @typeParam TB Name of the table.
* @typeParam KeyColumns Tuple of the names of the table's key columns.
* Defaults to `[]`, indicating no key columns. Supports up to 4 columns.
* @typeParam SelectedColumns Columns to return from selection queries.
* Defaults to `['*']`, returning all columns. May specify aliases.
* @typeParam SelectedObject Type of objects returned by select queries.
* @typeParam InsertedObject Type of objects inserted into the table.
* @typeParam UpdatingObject Type of objects used to update rows of the table.
* @typeParam Type of the count of the number of affected rows.
* @typeParam InsertReturnColumns Columns to return from the table on insert
* queries that return columns. `['*']` returns all columns; `[]` returns
* none. May specify aliases. Defaults to `KeyColumns`.
* @typeParam UpdateReturnColumns Columns to return from the table on update
* queries that return columns. `['*']` returns all columns; `[]` returns
* none and is the default. May specify aliases.
* @typeParam InsertReturn Type returned from inserts. Defaults to an object
* whose properties are the columns of `InsertReturnColumns`.
* @typeParam UpdateReturn Type returned from updates. Defaults to an object
* whose properties are the columns of `UpdateReturnColumns`.
*/
export class TableMapper<
DB,
TB extends keyof DB & string,
KeyColumns extends
| Readonly<SelectableColumnTuple<DB[TB]>>
| Readonly<[]> = [],
SelectedColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'] = ['*'],
SelectedObject = SelectedRow<
DB,
TB,
SelectedColumns extends ['*'] ? never : SelectedColumns[number],
SelectedColumns
>,
InsertedObject = Insertable<DB[TB]>,
UpdatingObject = Updateable<DB[TB]>,
ReturnCount = bigint,
InsertReturnColumns extends
| Readonly<SelectionColumn<DB, TB>[]>
| ['*'] = Readonly<KeyColumns>,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'] = [],
InsertReturn = InsertReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, InsertReturnColumns[number]>,
UpdateReturn = UpdateReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, UpdateReturnColumns[number]>
> extends AbstractTableMapper<
DB,
TB,
KeyColumns,
SelectedColumns,
SelectedObject,
InsertedObject,
UpdatingObject,
ReturnCount,
InsertReturnColumns,
UpdateReturnColumns,
InsertReturn,
UpdateReturn
> {
/**
* Returns a new table mapper that uses the provided transformations, along
* with the settings of the current table mapper.
* @param transforms The transforms to use.
* @returns A new table mapper that uses the provided transforms.
*/
withTransforms<
SelectedObject = SelectedRow<
DB,
TB,
SelectedColumns extends ['*'] ? never : SelectedColumns[number],
SelectedColumns
>,
InsertedObject = Insertable<DB[TB]>,
UpdatingObject = Updateable<DB[TB]>,
ReturnCount = bigint,
InsertReturn = InsertReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, InsertReturnColumns[number]>,
UpdateReturn = UpdateReturnColumns extends ['*']
? Selectable<DB[TB]>
: Selection<DB, TB, UpdateReturnColumns[number]>
>(
transforms: Readonly<
TableMapperTransforms<
DB,
TB,
KeyColumns,
SelectedColumns,
SelectedObject,
InsertedObject,
UpdatingObject,
ReturnCount,
InsertReturnColumns,
UpdateReturnColumns,
InsertReturn,
UpdateReturn
>
>
) {
const transformingTableMapper = new TableMapper<
DB,
TB,
KeyColumns,
SelectedColumns,
SelectedObject,
InsertedObject,
UpdatingObject,
ReturnCount,
InsertReturnColumns,
UpdateReturnColumns,
InsertReturn,
UpdateReturn
>(this.db, this.tableName, this.settings);
| transformingTableMapper.transforms = transforms; |
return transformingTableMapper;
}
}
| src/mappers/table-mapper.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn\n > = {};",
"score": 0.9240609407424927
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " KeyColumns,\n SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn,",
"score": 0.9124711751937866
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " KeyColumns,\n SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn,",
"score": 0.9124711751937866
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,\n InsertReturn,\n UpdateReturn,\n this,\n Parameters,",
"score": 0.9122394323348999
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " DB,\n TB,\n KeyColumns,\n SelectedColumns,\n SelectedObject,\n InsertedObject,\n UpdatingObject,\n ReturnCount,\n InsertReturnColumns,\n UpdateReturnColumns,",
"score": 0.9058107733726501
}
] | typescript | transformingTableMapper.transforms = transforms; |
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingUpdateQuery } from './update-query';
import { ParameterizableMappingQuery } from './parameterizable-query';
import { ParametersObject } from 'kysely-params';
import { CompilingMappingUpdateQuery } from './compiling-update-query';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
import { restrictValues } from '../lib/restrict-values';
/**
* Mapping query for updating rows into a database table,
* updating a specified subset of the updateable columns.
*/
export class SubsettingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn
>
extends MappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
>
implements ParameterizableMappingQuery
{
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a compiling query that can be executed multiple times with
* different parameters (if any parameters were provided), but which only
* compiles the underlying Kysely query builder on the first execution.
* Frees the query builder on the first execution to reduce memory usage.
* @typeParam Parameters Record characterizing the parameter names and
* types that were previously embedded in the query, if any.
* @returns A compiling update query.
*/
compile<
Parameters extends ParametersObject<Parameters> = {}
>(): CompilingMappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn,
Parameters
> {
return new CompilingMappingUpdateQuery(
this.db,
this.qb,
this.columnsToUpdate,
this.transforms,
this.returnColumns
);
}
protected override getUpdateColumns():
| Readonly<(keyof Updateable<DB[TB]> & string)[]>
| ['*'] {
return this.columnsToUpdate;
}
protected override setColumnValues(
qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
obj: Updateable<DB[TB]>
): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {
| return qb.set(restrictValues(obj, this.columnsToUpdate)); |
}
}
| src/queries/subsetting-update-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " | 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.9261841177940369
},
{
"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.924034595489502
},
{
"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.9045125246047974
},
{
"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.8823332786560059
},
{
"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.8817453980445862
}
] | typescript | return qb.set(restrictValues(obj, this.columnsToUpdate)); |
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/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.9098666906356812
},
{
"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.9033678770065308
},
{
"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.9017308354377747
},
{
"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.8983653783798218
},
{
"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.8898307085037231
}
] | typescript | .qb,
columnsToUpdate,
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/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.9026638269424438
},
{
"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.8962351083755493
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " const result = await this.loadUpdatingObject(\n this.qb,\n obj\n ).executeTakeFirst();\n return this.transforms.countTransform === undefined\n ? (result.numUpdatedRows as ReturnCount)\n : this.transforms.countTransform(result.numUpdatedRows);\n }\n /**\n * Updates rows with the values that result from transforming the object via",
"score": 0.8961012363433838
},
{
"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.8926081657409668
},
{
"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.8868484497070312
}
] | typescript | : result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
); |
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/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.9248028993606567
},
{
"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.9232999682426453
},
{
"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.8951992392539978
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new AnyColumnsMappingUpdateQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getUpdateQB()\n : applyQueryFilter(",
"score": 0.8802952766418457
},
{
"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.8695967793464661
}
] | 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.9380108118057251
},
{
"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.9051464200019836
},
{
"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.8718769550323486
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new AnyColumnsMappingUpdateQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getUpdateQB()\n : applyQueryFilter(",
"score": 0.8668571710586548
},
{
"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.8608155846595764
}
] | 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": " /**\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.933291494846344
},
{
"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.9299365878105164
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " * query builder. Subsequent executions reuse the compiled query.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(obj: InsertedObject): Promise<boolean> {\n const transformedObj = this.applyInsertTransform(obj);\n const compiledQuery = this.instantiateNoReturns({}, transformedObj);\n await this.db.executeQuery(compiledQuery);\n return true;\n }",
"score": 0.9192331433296204
},
{
"filename": "src/queries/compiling-select-query.ts",
"retrieved_chunk": " * query builder. Subsequent executions reuse the compiled query.\n * @param params Record characterizing the parameter names and types.\n * Pass in `{}` if the query has no parameters.\n * @returns An object for the selected rows, or null if not found.\n */\n async returnOne(params: Parameters): Promise<SelectedObject | null> {\n const result = await this.#parameterizedQuery.executeTakeFirst(\n this.db,\n params\n );",
"score": 0.9114677309989929
},
{
"filename": "src/queries/delete-query.ts",
"retrieved_chunk": " Parameters extends ParametersObject<Parameters> = {}\n >(): CompilingMappingDeleteQuery<DB, TB, QB, ReturnCount, Parameters> {\n return new CompilingMappingDeleteQuery(this.db, this.qb, this.transforms);\n }\n /**\n * Runs the query, returning the number of rows deleted, converted to\n * the required client representation.\n * @returns Number of rows deleted, in client-requested representation.\n */\n async returnCount(): Promise<ReturnCount> {",
"score": 0.9098539352416992
}
] | 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.9400016069412231
},
{
"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.901084303855896
},
{
"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.8743531703948975
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n obj: Updateable<DB[TB]>\n ): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {\n return qb.set(restrictValues(obj, this.columnsToUpdate));\n }\n}",
"score": 0.86042320728302
},
{
"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.8582901954650879
}
] | typescript | objOrObjs.map((obj) => restrictValues(obj, this.columnsToInsert))
); |
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.9357701539993286
},
{
"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.9217382669448853
},
{
"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.8922187685966492
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " async returnCount(\n params: Parameters,\n obj: UpdatingObject\n ): Promise<ReturnCount> {\n const transformedObj = this.applyUpdateTransform(obj);\n const compiledQuery = this.instantiateNoReturns(params, transformedObj);\n const result = await this.db.executeQuery(compiledQuery);\n return this.transforms.countTransform === undefined\n ? (result.numAffectedRows as ReturnCount)\n : this.transforms.countTransform(result.numAffectedRows!);",
"score": 0.8913809061050415
},
{
"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.8729573488235474
}
] | typescript | .instantiateWithReturns({}, transformedObj); |
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/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.887511670589447
},
{
"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.8844307661056519
},
{
"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.881649374961853
},
{
"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.8763717412948608
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " Insertable<DB[TB]>\n> {\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToInsert: Readonly<\n (keyof Insertable<DB[TB]> & string)[]\n >,\n protected readonly transforms: Readonly<\n InsertTransforms<",
"score": 0.8739874362945557
}
] | typescript | override getUpdateColumns():
| Readonly<(keyof Updateable<DB[TB]> & string)[]>
| ['*'] { |
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.9178920388221741
},
{
"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.9163854122161865
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " * query builder. Subsequent executions reuse the compiled query.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(obj: InsertedObject): Promise<boolean> {\n const transformedObj = this.applyInsertTransform(obj);\n const compiledQuery = this.instantiateNoReturns({}, transformedObj);\n await this.db.executeQuery(compiledQuery);\n return true;\n }",
"score": 0.8887149095535278
},
{
"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.8766112327575684
},
{
"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.8733873963356018
}
] | typescript | const compiledQuery = this.instantiateWithReturns(params, transformedObj); |
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": " DB,\n TB,\n SelectedColumns,\n SelectedObject,\n SelectQueryBuilder<DB, TB, object>\n > {\n return new MappingSelectQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getSelectQB()",
"score": 0.8490736484527588
},
{
"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.8388386964797974
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " * the provided filter or Kysely binary operation.\n * @param filter Optional filter to apply to the query or the left-hand-side\n * of a Kysely binary operation.\n * @returns A mapping query for retrieving rows as objects.\n */\n select<RE extends ReferenceExpression<DB, TB>>(\n lhs: RE,\n op: ComparisonOperatorExpression,\n rhs: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 0.8262311816215515
},
{
"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.8237383365631104
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new AnyColumnsMappingUpdateQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getUpdateQB()\n : applyQueryFilter(",
"score": 0.8205039501190186
}
] | typescript | keyColumns.forEach((column, i) => { |
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(users2[0].handle).toEqual(USERS[1].handle);\n });\n it('selects with a matching field filter', async () => {\n await userMapper.insert().run(USERS);\n let users = await userMapper\n .select({\n name: USERS[0].name,\n })\n .returnAll();\n expect(users.length).toEqual(2);",
"score": 0.8999560475349426
},
{
"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.8930675983428955
},
{
"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.892810583114624
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('selects many returning selected columns and aliases', async () => {\n const ids = await userMapper.insert().returnAll(USERS);\n const mapper = new TableMapper(db, 'users', {\n selectedColumns: ['id', 'handle as h'],\n });\n // Should allow access to aliased columns\n (await mapper.select().returnAll())[0].h;",
"score": 0.887453556060791
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " });\n });\n it('selects via a multi-column key tuple (definition order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id', 'name'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select([3, 'Sue']).returnAll();\n expect(users.length).toEqual(1);\n expect(users[0].name).toEqual(USERS[2].name);",
"score": 0.8843836784362793
}
] | 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": " DB,\n TB,\n SelectedColumns,\n SelectedObject,\n SelectQueryBuilder<DB, TB, object>\n > {\n return new MappingSelectQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getSelectQB()",
"score": 0.8481485843658447
},
{
"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.8341680765151978
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " * the provided filter or Kysely binary operation.\n * @param filter Optional filter to apply to the query or the left-hand-side\n * of a Kysely binary operation.\n * @returns A mapping query for retrieving rows as objects.\n */\n select<RE extends ReferenceExpression<DB, TB>>(\n lhs: RE,\n op: ComparisonOperatorExpression,\n rhs: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 0.8232766389846802
},
{
"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.8215621113777161
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new AnyColumnsMappingUpdateQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getUpdateQB()\n : applyQueryFilter(",
"score": 0.820404052734375
}
] | 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/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.8711557388305664
},
{
"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.8616409301757812
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " this.updateReturnColumns = settings.updateReturnColumns ?? ([] as any);\n }\n /**\n * Returns a mapping query for deleting the rows of the table that match\n * the provided filter or Kysely binary operation.\n * @param filter Optional filter to apply to the query or the left-hand-side\n * of a Kysely binary operation.\n * @returns A mapping query for deleting rows.\n */\n delete<RE extends ReferenceExpression<DB, TB>>(",
"score": 0.8591027855873108
},
{
"filename": "src/queries/select-query.ts",
"retrieved_chunk": " SelectQueryBuilder<DB, TB, Parameters>,\n Parameters\n > {\n return new CompilingMappingSelectQuery(this.db, this.qb, this.transforms);\n }\n /**\n * Modifies the underlying Kysely query builder. All columns given in\n * `SelectedColumns` are already selected, but you can select additional\n * columns or add column aliases.\n * @param factory A function that takes the current query builder and",
"score": 0.8573479652404785
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " this.returnColumns as Readonly<\n (keyof Selectable<DB[TB]> & string)[]\n >\n );\n }\n return this.#returningQB;\n }\n /**\n * Loads the objects to be inserted into the query builder.\n * @param qb The query builder to load the objects into.",
"score": 0.8532084226608276
}
] | 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/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " * Returns a reference to a column, which can be a generated string.\n * (Shorthand for `db.dynamic.ref(column)`.)\n * @param column The column name being referenced.\n * @returns A reference to the given column.\n */\n ref(column: string) {\n return this.db.dynamic.ref(column);\n }\n /**\n * Returns a mapping query for selecting rows of the table that match",
"score": 0.8316845893859863
},
{
"filename": "src/queries/select-query.ts",
"retrieved_chunk": " * (if provided) to map the row to an object of type `SelectedObject`.\n * @returns An object for the selected rows, or null if not found.\n */\n async returnOne(): Promise<SelectedObject | null> {\n const result = await this.qb.executeTakeFirst();\n if (!result) return null;\n return this.transforms.selectTransform === undefined\n ? result\n : this.transforms.selectTransform(result);\n }",
"score": 0.8223580718040466
},
{
"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.8219205737113953
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " return new MappingInsertQuery(\n this.db,\n factory(this.qb),\n this.transforms,\n this.returnColumns\n );\n }\n /**\n * Inserts the provided objects into the table as rows, first transforming\n * them into rows via `insertTransform` (if defined). For each row inserted,",
"score": 0.8158407211303711
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " this.returnColumns as Readonly<\n (keyof Selectable<DB[TB]> & string)[]\n >\n );\n }\n return this.#returningQB;\n }\n /**\n * Loads the objects to be inserted into the query builder.\n * @param qb The query builder to load the objects into.",
"score": 0.8155443072319031
}
] | 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-all.test.ts",
"retrieved_chunk": " expect(users2[0].handle).toEqual(USERS[1].handle);\n });\n it('selects with a matching field filter', async () => {\n await userMapper.insert().run(USERS);\n let users = await userMapper\n .select({\n name: USERS[0].name,\n })\n .returnAll();\n expect(users.length).toEqual(2);",
"score": 0.8997906446456909
},
{
"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.8930585980415344
},
{
"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.8918527364730835
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('selects many returning selected columns and aliases', async () => {\n const ids = await userMapper.insert().returnAll(USERS);\n const mapper = new TableMapper(db, 'users', {\n selectedColumns: ['id', 'handle as h'],\n });\n // Should allow access to aliased columns\n (await mapper.select().returnAll())[0].h;",
"score": 0.8873732089996338
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " });\n });\n it('selects via a multi-column key tuple (definition order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id', 'name'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select([3, 'Sue']).returnAll();\n expect(users.length).toEqual(1);\n expect(users[0].name).toEqual(USERS[2].name);",
"score": 0.8848481178283691
}
] | 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: '[email protected]',
});
expect(insertReturn).toEqual({ id: expect.any(Number) });
const readUser = await userMapperReturningID.select().returnAll();
expect(readUser).toEqual([
{ id: 1, name: 'John Doe', handle: 'johndoe', email: null },
]);
});
it('subsets inserted columns, including ID', async () => {
const subsetQuery = userMapperReturningNothing
.insert()
.columns(['id', 'name', 'handle']);
await subsetQuery.run({
id: 10,
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
const readUser = await userMapperReturningID.select().returnAll();
expect(readUser).toEqual([
{ id: 10, name: 'John Doe', handle: 'johndoe', email: null },
]);
});
it('requires all subsetted columns to be inserted', async () => {
const subsetQuery = userMapperReturningID
.insert()
.columns(['name', 'handle', 'email']);
const insertValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => subsetQuery.returnOne(insertValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await subsetQuery.run({ ...insertValues, email: null });
expect(success).toBe(true);
});
it('provides insertTransform with column subset', async () => {
expect.assertions(1);
const mapper = userMapperReturningID.withTransforms({
| insertTransform: (source, columns) => { |
expect(columns).toEqual(['name', 'handle']);
return source;
},
});
await mapper.insert().columns(['name', 'handle']).run({
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
});
});
| src/tests/insert-columns.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " const success = await subsetQuery.run({ ...updateValues, email: null });\n expect(success).toBe(true);\n });\n it('provides updateTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = new TableMapper(db, 'users').withTransforms({\n updateTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },",
"score": 0.9455965161323547
},
{
"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.9142239093780518
},
{
"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.8980424404144287
},
{
"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.8975924253463745
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " });\n it('requires all indicated columns to be inserted', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n const insertValues = { name: 'John Doe', handle: 'johndoe' };\n expect(() => compilation.returnOne(insertValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 0.8936233520507812
}
] | 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/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.8840424418449402
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new AnyColumnsMappingUpdateQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getUpdateQB()\n : applyQueryFilter(",
"score": 0.8766101598739624
},
{
"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.8705609440803528
},
{
"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.8599768280982971
},
{
"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.8567382097244263
}
] | typescript | this.qb = qb.set(parameterizedValues) as QB; |
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting an array of objects without transformation', () => {
it('inserts readonly objects', async () => {
const obj = {
name: 'John Doe' as const,
handle: 'johndoe' as const,
email: '[email protected]' as const,
} as const;
await userMapperReturningAll.insert().run(obj);
await userMapperReturningAll.insert().returnAll([obj]);
await userMapperReturningAll.insert().returnOne(obj);
});
it('inserts multiple via run() without returning columns', async () => {
const success = await userMapperReturningDefault.insert().run(USERS);
expect(success).toBe(true);
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
result.id;
// @ts-expect-error - can't access columns when returning nothing
result[0].id;
});
});
it('inserts multiple via returnAll() without returning columns', async () => {
const results = await userMapperReturningDefault.insert().returnAll(USERS);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple via returnOne() without returning columns', async () => {
const results = await userMapperReturningDefault
.insert()
.returnOne(USERS[0]);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(1);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple returning configured return columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
expect(Object.keys(insertReturns[i]).length).toEqual(1);
}
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
| const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id }); |
const post1 = Object.assign({}, POSTS[1], { userId: insertReturns[1].id });
const post2 = Object.assign({}, POSTS[2], { userId: insertReturns[2].id });
const updateReturns = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnAll([post0, post1, post2]);
expect(updateReturns.length).toEqual(3);
for (let i = 0; i < updateReturns.length; i++) {
expect(updateReturns[i].id).toBeGreaterThan(0);
expect(updateReturns[i].t).toEqual(POSTS[i].title);
expect(Object.keys(updateReturns[i]).length).toEqual(2);
}
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns[0].title;
// @ts-expect-error - check return types
updateReturns[0].userId;
});
});
it('inserts multiple returning no columns by default', async () => {
const insertReturns = await userMapperReturningDefault
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
});
it('inserts multiple explicitly returning no columns', async () => {
const insertReturns = await userMapperReturningNothing
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
insertReturns[0].id;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturns = await mapper.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
expect(insertReturns[0]).toEqual({
id: insertReturns[0].id,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturns[0].id);
((_: string) => {})(insertReturns[0].handle);
const newHandle = 'newHandle';
const updateReturns = await mapper
.update(1)
.returnAll({ handle: newHandle });
expect(updateReturns.length).toEqual(1);
expect(updateReturns[0]).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturns[0].name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturns[0].name;
// @ts-expect-error - check return types
updateReturns[0].id;
});
});
it('inserts multiple configured to return all columns', async () => {
const insertReturns = await userMapperReturningAll
.insert()
.returnAll(USERS);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
}
expect(insertReturns).toEqual(
USERS.map((user, i) =>
Object.assign({}, user, { id: insertReturns[i].id })
)
);
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(insertReturns[0].name);
});
ignore('detects inserting an array of objects type errors', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{ email: '[email protected]' }]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{ email: '[email protected]' }]);
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().returnAll([USERS[0]]))[0].handle;
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().run([USERS[0]]))[0].handle;
});
});
| src/tests/insert-array.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/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.9082385301589966
},
{
"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.9014096260070801
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " it('deletes rows specified via binary operation', async () => {\n await userMapper.insert().run(USERS);\n const count1 = await userMapper\n .delete('name', '=', USERS[0].name)\n .returnCount();\n expect(count1).toEqual(2);\n const users = await userMapper.select().returnAll();\n expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });",
"score": 0.8817391991615295
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " const insertReturn = await userMapperReturningAll\n .insert()\n .returnOne(USERS[0]);\n expect(insertReturn.id).toBeGreaterThan(0);\n expect(insertReturn.email).toEqual(USERS[0].email);\n const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });\n expect(insertReturn).toEqual(expectedUser);\n });\n ignore('detects type errors inserting a single object', async () => {\n // @ts-expect-error - inserted object must have all required columns",
"score": 0.8717398643493652
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " .update(sql`id > ${insertReturns[0].id}`)\n .returnCount(updateValues);\n expect(updateCount).toEqual(BigInt(2));\n const readUsers = await userMapperReturningID\n .select('id', '>', insertReturns[0].id)\n .returnAll();\n expect(readUsers.length).toEqual(2);\n for (const user of readUsers) {\n expect(user.email).toEqual(updateValues.email);\n }",
"score": 0.8683088421821594
}
] | typescript | const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id }); |
import { Insertable, Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
import {
createUserMapperReturningAll,
createUserMapperReturningNothing,
} from './utils/test-mappers';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningAll = createUserMapperReturningAll(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
describe('compiled insertions', () => {
it('compiles a non-returning insert query without transformation', async () => {
const compilation = userMapperReturningNothing
.insert()
.columns(['name', 'handle'])
.compile();
// test run()
const success1 = await compilation.run(USERS[1]);
expect(success1).toBe(true);
// test returnOne()
const success2 = await compilation.returnOne(USERS[2]);
expect(success2).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].handle).toEqual(USERS[1].handle);
expect(readUsers[0].email).toEqual(null);
expect(readUsers[1].handle).toEqual(USERS[2].handle);
expect(readUsers[1].email).toEqual(null);
});
it('compiles a returning insert query without transformation', async () => {
const compilation = userMapperReturningAll
.insert()
.columns(['name', 'handle', 'email'])
.compile();
// test returnOne()
const insertReturn = await compilation.returnOne(USERS[0]);
expect(insertReturn).toEqual({ ...USERS[0], id: 1 });
// Ensure that the provided columns are accessible
((_: string) => {})(insertReturn!.name);
// test run()
const success1 = await compilation.run(USERS[1]);
expect(success1).toBe(true);
// test that non-specified columns are not inserted
const success2 = await compilation.run({ ...USERS[2], id: 100 });
expect(success2).toBe(true);
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
expect(readUsers[1].handle).toEqual(USERS[1].handle);
expect(readUsers[2].handle).toEqual(USERS[2].handle);
expect(readUsers[2].id).toEqual(3);
ignore('check compile-time types', () => {
compilation.returnOne({
name: 'xyz',
handle: 'pdq',
email: '[email protected]',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
});
// @ts-expect-error - only expected columns are returned
insertReturn!.notThere;
});
});
it('compiles an insert query with transformation', async () => {
expect.assertions(7);
| const columnSubset: (keyof Insertable<Users>)[] = [
'name',
'handle',
'email',
]; |
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: User, returns) =>
new User(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const user1: Readonly<User> = new User(
0,
'John',
'Doe',
'johndoe',
'[email protected]'
);
const user2: Readonly<User> = new User(
0,
'Sam',
'Gamgee',
'sg',
'[email protected]'
);
const user3 = new User(100, 'Sue', 'Rex', 'srex', '[email protected]');
const compilation = transformMapper
.insert()
.columns(columnSubset)
.compile();
// test returnOne()
const insertReturn = await compilation.returnOne(user1);
expect(insertReturn).toEqual(User.create(1, user1));
// Ensure that the provided columns are accessible
((_: string) => {})(insertReturn!.firstName);
// test run()
const success1 = await compilation.run(user2);
expect(success1).toBe(true);
// test that non-specified columns are not inserted
const success2 = await compilation.run(user3);
expect(success2).toBe(true);
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(1, user1),
User.create(2, user2),
User.create(3, user3),
]);
ignore('check compile-time types', () => {
// @ts-expect-error - only insertable objecs are allowed
compilation.returnOne(USERS[0]);
// @ts-expect-error - only insertable objecs are allowed
compilation.run(USERS[0]);
});
});
it('requires all indicated columns to be inserted', async () => {
const compilation = userMapperReturningAll
.insert()
.columns(['name', 'handle', 'email'])
.compile();
const insertValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne(insertValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({ ...insertValues, email: null });
expect(success).toBe(true);
});
});
| src/tests/insert-compile.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " notThere: 32,\n }\n );\n });\n });\n it('compiles an update query with transformation', async () => {\n expect.assertions(12);\n const columnSubset: (keyof Updateable<Users>)[] = ['name'];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['*'],",
"score": 0.9438372254371643
},
{
"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.9147948026657104
},
{
"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.9028327465057373
},
{
"filename": "src/tests/setting-types.test.ts",
"retrieved_chunk": " Readonly<['id', 'name']> // should not error\n >(db, 'users', {});\n });\n it('accepts readonly return columns', () => {\n new TableMapper<\n Database,\n 'users',\n ['id'],\n ['*'],\n Selectable<Users>,",
"score": 0.8955987095832825
},
{
"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.8896106481552124
}
] | typescript | const columnSubset: (keyof Insertable<Users>)[] = [
'name',
'handle',
'email',
]; |
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/insert-single.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting a single object without transformation', () => {\n it('inserts one returning no columns by default', async () => {\n const success = await userMapperReturningDefault.insert().run(USERS[0]);\n expect(success).toBe(true);\n const readUser0 = await userMapperReturningAll\n .select('email', '=', USERS[0].email!)\n .returnOne();",
"score": 0.9092265367507935
},
{
"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.9021705985069275
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " });\n });\n it('selects via a multi-column key tuple (definition order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id', 'name'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select([3, 'Sue']).returnAll();\n expect(users.length).toEqual(1);\n expect(users[0].name).toEqual(USERS[2].name);",
"score": 0.9014898538589478
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users2[0].handle).toEqual(USERS[1].handle);\n });\n it('selects with a matching field filter', async () => {\n await userMapper.insert().run(USERS);\n let users = await userMapper\n .select({\n name: USERS[0].name,\n })\n .returnAll();\n expect(users.length).toEqual(2);",
"score": 0.9011316895484924
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " mapper.select(1);\n });\n });\n it('selects via a multi-column key tuple (different order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['name', 'id'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select(['Sue', 3]).returnAll();\n expect(users.length).toEqual(1);",
"score": 0.8991748690605164
}
] | 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/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.9582856297492981
},
{
"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.902518093585968
},
{
"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.8777718544006348
},
{
"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.8649502992630005
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new AnyColumnsMappingUpdateQuery(\n this.db,\n filterOrLHS === undefined\n ? this.getUpdateQB()\n : applyQueryFilter(",
"score": 0.8563821315765381
}
] | typescript | this.qb = qb.values(parameterizedValues) as QB; |
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this | .instantiateNoReturns({}, transformedObj); |
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
| src/queries/compiling-insert-query.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * Runs the query, inserting rows into the table without returning any columns.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(objOrObjs: InsertedObject | InsertedObject[]): Promise<boolean> {\n await this.loadInsertedObjects(this.qb, objOrObjs).execute();\n return true;\n }\n /**\n * Returns an array of the columns to be inserted, with",
"score": 0.9446242451667786
},
{
"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.9345754384994507
},
{
"filename": "src/queries/compiling-select-query.ts",
"retrieved_chunk": " * Accepts values for any parameters embedded in the query.\n *\n * On the first execution, compiles and discards the underlying Kysely\n * query builder. Subsequent executions reuse the compiled query.\n * @param params Record characterizing the parameter names and types.\n * Pass in `{}` if the query has no parameters.\n * @returns An array of objects for the selected rows, possibly empty.\n */\n async returnAll(params: Parameters): Promise<SelectedObject[]> {\n const results = await this.#parameterizedQuery.execute(this.db, params);",
"score": 0.9305154085159302
},
{
"filename": "src/queries/compiling-select-query.ts",
"retrieved_chunk": " * query builder. Subsequent executions reuse the compiled query.\n * @param params Record characterizing the parameter names and types.\n * Pass in `{}` if the query has no parameters.\n * @returns An object for the selected rows, or null if not found.\n */\n async returnOne(params: Parameters): Promise<SelectedObject | null> {\n const result = await this.#parameterizedQuery.executeTakeFirst(\n this.db,\n params\n );",
"score": 0.9197577238082886
},
{
"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.9140645265579224
}
] | typescript | .instantiateNoReturns({}, transformedObj); |
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/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.8302430510520935
},
{
"filename": "src/lib-components/Dialog/index.tsx",
"retrieved_chunk": " <Button\n onClick={onHide}\n style={{ backgroundColor: color[type], color: '#ffffff' }}\n >\n {acceptLabel}\n </Button>\n ) : (\n <div>\n <Button onClick={rejectFunction} style={{ color: color[type] }}>\n {rejectLabel}",
"score": 0.828815221786499
},
{
"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.8209952116012573
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8165693283081055
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " >\n {link.title}\n </div>\n </SameTabLink>\n )}\n {showChildrenLinks[index] ? (\n <ExpandLessIcon\n htmlColor='white'\n sx={{ marginLeft: '-10px', paddingLeft: '1px' }}\n />",
"score": 0.8161242008209229
}
] | 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/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.840601921081543
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " link={link}\n toggleDrawer={\n showChildrenLinks.length ? undefined : toggleDrawer\n }\n >\n <NewTabLinkWithoutChild link={link} />\n </NewTabLinkDiv>\n ) : (\n <SameTabLink\n to={link.href as string}",
"score": 0.8397467732429504
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " aria-haspopup='true'\n onClick={handleSystemsMenu}\n color='inherit'\n >\n <SystemsButton>\n <img src={systemsMenuIcon} alt='Systems Menu' />\n </SystemsButton>\n </IconButton>\n <StyledSystemMenu\n id='menu-appbar'",
"score": 0.8350430727005005
},
{
"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.829889178276062
},
{
"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.8248078227043152
}
] | typescript | <SideMenu
visibility={drawerVisibility} |
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": " </PositionsContainer>\n )}\n <LogoutButton\n variant='text'\n type='button'\n onClick={() => {\n logoutFunction();\n }}\n >\n Sair",
"score": 0.8346642255783081
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " },\n setVisibility: {\n name: 'setVisibility',\n control: { disable: true },\n description:\n 'useState set function passed to define the visibility of sidemenu in actions.',\n table: {\n category: 'SideMenu'\n }\n },",
"score": 0.8240102529525757
},
{
"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.8209710121154785
},
{
"filename": "src/stories/SideMenu.stories.tsx",
"retrieved_chunk": " table: {\n category: 'SideMenu'\n }\n },\n top: {\n name: 'top',\n description: 'Top spacing of sidemenu to top of your page.',\n table: {\n category: 'SideMenu'\n }",
"score": 0.8109322786331177
},
{
"filename": "src/stories/Dialog.stories.tsx",
"retrieved_chunk": "DialogError.args = {\n type: 'error',\n title: 'Error Dialog Title',\n children:\n 'DialogError presents a message to the user and includes a confirmation button and a cancel button, ensuring that the user acknowledges the message.'\n};",
"score": 0.8102176189422607
}
] | 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: '[email protected]',
footerLink: 'https://www.google.com',
footerTextLink: 'Site',
footerDescription: "Footer's description with \n line break",
footerCopyrightText: 'CIn UFPE | All rights reserved'
};
| src/stories/Page.stories.tsx | CinCoders-cinnamon-b42005e | [
{
"filename": "src/stories/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.9193999767303467
},
{
"filename": "src/lib-components/ErrorScreen/index.tsx",
"retrieved_chunk": " return <Maintenance />;\n }\n}\nexport const ErrorScreen = (props: ErrorScreenProps) => {\n const { errorType } = props;\n return <>{errorMapping(errorType)}</>;\n};\nconst NotFound = () => {\n return (\n <NotFoundWrapper>",
"score": 0.8733924627304077
},
{
"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.8717139363288879
},
{
"filename": "src/lib-components/Navbar/index.tsx",
"retrieved_chunk": " }\n })\n : systemsList;\n return (\n <>\n <GlobalStyles styles={{ body: { paddingRight: '0px !important' } }} />\n {isLandingPage ? (\n <ParentNav>\n <StyledAppBar>\n <StyledToolbar>",
"score": 0.8706381320953369
},
{
"filename": "src/components/SideMenu/index.tsx",
"retrieved_chunk": " {iconUrl && <img src={iconUrl} alt={`${title} icon`} />}\n {IconComponent && <IconComponent />}\n </ListItemIcon>\n );\n}\nfunction NewTabLinkWithoutChild(props: { link: SideMenuLink }) {\n const { link } = props;\n return (\n <>\n <div",
"score": 0.8701273202896118
}
] | typescript | Page
navbar={{ |
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.9210930466651917
},
{
"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.9090287089347839
},
{
"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.8951244354248047
},
{
"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.8945671916007996
},
{
"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.8941900730133057
}
] | typescript | insertReturnTransform: (source, returns) => { |
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.9564200639724731
},
{
"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.9310645461082458
},
{
"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.9301822185516357
},
{
"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.9206899404525757
},
{
"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.9189813137054443
}
] | typescript | insertTransform: (source: InsertedUser, columns) => { |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
| insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
}); |
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 0.9447697401046753
},
{
"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.9382504224777222
},
{
"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.9298848509788513
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " it('accepts readonly transforms', () => {\n const transforms = {\n countTransform: (count: bigint) => count,\n } as const;\n new TableMapper(db, 'users', {}).withTransforms(transforms);\n });\n});",
"score": 0.9096498489379883
},
{
"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.9031276702880859
}
] | 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": " 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.9517730474472046
},
{
"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.9363011121749878
},
{
"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.9323591589927673
},
{
"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.9282275438308716
},
{
"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.9173213243484497
}
] | typescript | source, results) => { |
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapper: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['*']
>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapper = new TableMapper(db, 'posts', {
insertReturnColumns: ['*'],
}).withTransforms({
countTransform: (count) => Number(count),
});
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting a single object without transformation', () => {
it('inserts one returning no columns by default', async () => {
| const success = await userMapperReturningDefault.insert().run(USERS[0]); |
expect(success).toBe(true);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
});
it('inserts one explicitly returning no columns', async () => {
const insertReturn = await userMapperReturningNothing
.insert()
.returnOne(USERS[0]);
expect(insertReturn).toBe(undefined);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
ignore('type errors', () => {
// @ts-expect-error - check return type
insertReturn.id;
});
});
it('inserts one returning configured return columns', async () => {
const insertReturn1 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
expect(insertReturn1.id).toBeGreaterThan(0);
expect(Object.keys(insertReturn1).length).toEqual(1);
const readUser0 = await userMapperReturningAll
.select('id', '=', insertReturn1.id)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id });
const insertReturn2 = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnOne(post0);
expect(insertReturn2.id).toBeGreaterThan(0);
expect(insertReturn2.t).toEqual(POSTS[0].title);
expect(Object.keys(insertReturn2).length).toEqual(2);
const readPost0 = await postTableMapper
.select(({ and, cmpr }) =>
and([
cmpr('id', '=', insertReturn2.id),
cmpr('title', '=', insertReturn2.t),
])
)
.returnOne();
expect(readPost0?.likeCount).toEqual(post0.likeCount);
ignore('check return types', () => {
// @ts-expect-error - check return types
insertReturn1.title;
// @ts-expect-error - check return types
insertReturn1.userId;
// @ts-expect-error - check return types
insertReturn2.title;
// @ts-expect-error - check return types
insertReturn2.userId;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturn = await mapper.insert().returnOne(USERS[0]);
expect(insertReturn).toEqual({
id: 1,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturn.id);
((_: string) => {})(insertReturn.handle);
const newHandle = 'newHandle';
const updateReturn = await mapper
.update(1)
.returnOne({ handle: newHandle });
expect(updateReturn).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturn!.name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturn.name;
// @ts-expect-error - check return types
updateReturn!.id;
});
});
it('inserts one configured to return all columns', async () => {
const insertReturn = await userMapperReturningAll
.insert()
.returnOne(USERS[0]);
expect(insertReturn.id).toBeGreaterThan(0);
expect(insertReturn.email).toEqual(USERS[0].email);
const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });
expect(insertReturn).toEqual(expectedUser);
});
ignore('detects type errors inserting a single object', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({ email: '[email protected]' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: '[email protected]' });
// @ts-expect-error - only requested columns are returned
(await userMapperReturningID.insert().returnOne(USERS[0])).name;
// @ts-expect-error - only requested columns are returned
(await userMapperReturningDefault.insert().run(USERS[0])).name;
});
});
| src/tests/insert-single.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id', 'title as t'],\n }).withTransforms({\n countTransform: (count) => Number(count),\n });\n});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting an array of objects without transformation', () => {\n it('inserts readonly objects', async () => {\n const obj = {",
"score": 0.9578313231468201
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " createUserMapperReturningIDAndHandleAsH(db);\n userMapperReturningAll = createUserMapperReturningAll(db);\n});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('general update', () => {\n it('updates nothing returning zero update count', async () => {\n const updateValues = { email: '[email protected]' };\n const success = await userMapperReturningAll\n .update({ id: 1 })",
"score": 0.9060223698616028
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " const count = await userMapper\n .delete({ name: USERS[0].name })\n .returnCount();\n expect(count).toEqual(0);\n const success = await userMapper.delete({ name: USERS[0].name }).run();\n expect(success).toEqual(false);\n });\n it('deletes rows without returning a count', async () => {\n const testMapper = new TableMapper(db, 'users').withTransforms({\n countTransform: (count) => Number(count),",
"score": 0.9007683992385864
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('deleting rows via TableMapper', () => {\n it('accepts readonly filters', async () => {\n const filter = { name: 'Not There' as const } as const;\n await userMapper.delete(filter).run();\n await userMapper.delete(filter).returnCount();\n });\n it(\"doesn't delete anything if no rows match\", async () => {",
"score": 0.8978496789932251
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('deletes rows returning the deletion count inferred as a number', async () => {\n const testMapper = new TableMapper(db, 'users').withTransforms({\n countTransform: (count) => Number(count),\n });\n await testMapper.insert().run(USERS);\n const count = await testMapper\n .delete({ name: USERS[0].name })",
"score": 0.8964837789535522
}
] | typescript | const success = await userMapperReturningDefault.insert().run(USERS[0]); |
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapper: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['*']
>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapper = new TableMapper(db, 'posts', {
insertReturnColumns: ['*'],
}).withTransforms({
countTransform: (count) => Number(count),
});
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting a single object without transformation', () => {
it('inserts one returning no columns by default', async () => {
const success = await userMapperReturningDefault.insert().run(USERS[0]);
expect(success).toBe(true);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
});
it('inserts one explicitly returning no columns', async () => {
const insertReturn = await userMapperReturningNothing
.insert()
.returnOne(USERS[0]);
expect(insertReturn).toBe(undefined);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
ignore('type errors', () => {
// @ts-expect-error - check return type
insertReturn.id;
});
});
it('inserts one returning configured return columns', async () => {
const insertReturn1 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
expect(insertReturn1.id).toBeGreaterThan(0);
expect(Object.keys(insertReturn1).length).toEqual(1);
const readUser0 = await userMapperReturningAll
.select('id', '=', insertReturn1.id)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
| const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id }); |
const insertReturn2 = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnOne(post0);
expect(insertReturn2.id).toBeGreaterThan(0);
expect(insertReturn2.t).toEqual(POSTS[0].title);
expect(Object.keys(insertReturn2).length).toEqual(2);
const readPost0 = await postTableMapper
.select(({ and, cmpr }) =>
and([
cmpr('id', '=', insertReturn2.id),
cmpr('title', '=', insertReturn2.t),
])
)
.returnOne();
expect(readPost0?.likeCount).toEqual(post0.likeCount);
ignore('check return types', () => {
// @ts-expect-error - check return types
insertReturn1.title;
// @ts-expect-error - check return types
insertReturn1.userId;
// @ts-expect-error - check return types
insertReturn2.title;
// @ts-expect-error - check return types
insertReturn2.userId;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturn = await mapper.insert().returnOne(USERS[0]);
expect(insertReturn).toEqual({
id: 1,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturn.id);
((_: string) => {})(insertReturn.handle);
const newHandle = 'newHandle';
const updateReturn = await mapper
.update(1)
.returnOne({ handle: newHandle });
expect(updateReturn).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturn!.name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturn.name;
// @ts-expect-error - check return types
updateReturn!.id;
});
});
it('inserts one configured to return all columns', async () => {
const insertReturn = await userMapperReturningAll
.insert()
.returnOne(USERS[0]);
expect(insertReturn.id).toBeGreaterThan(0);
expect(insertReturn.email).toEqual(USERS[0].email);
const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });
expect(insertReturn).toEqual(expectedUser);
});
ignore('detects type errors inserting a single object', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({ email: '[email protected]' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: '[email protected]' });
// @ts-expect-error - only requested columns are returned
(await userMapperReturningID.insert().returnOne(USERS[0])).name;
// @ts-expect-error - only requested columns are returned
(await userMapperReturningDefault.insert().run(USERS[0])).name;
});
});
| src/tests/insert-single.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/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.9457990527153015
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " .update(sql`id > ${insertReturns[0].id}`)\n .returnCount(updateValues);\n expect(updateCount).toEqual(BigInt(2));\n const readUsers = await userMapperReturningID\n .select('id', '>', insertReturns[0].id)\n .returnAll();\n expect(readUsers.length).toEqual(2);\n for (const user of readUsers) {\n expect(user.email).toEqual(updateValues.email);\n }",
"score": 0.9113974571228027
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const updateCount2 = await userMapperReturningAll\n .update({ name: 'Sue' })\n .returnCount(updateValues);\n expect(updateCount2).toEqual(2);\n const readUsers = await userMapperReturningID\n .select('name', '=', 'Sue')\n .returnAll();\n expect(readUsers.length).toEqual(2);\n expect(readUsers[0].email).toEqual(updateValues.email);\n expect(readUsers[1].email).toEqual(updateValues.email);",
"score": 0.9080328941345215
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(updateReturns2).toBeUndefined();\n const readUser2 = await userMapperReturningID\n .select({ id: insertReturns[0].id })\n .returnOne();\n expect(readUser2?.name).toEqual(updateValues2.name);\n expect(readUser2?.email).toEqual(updateValues2.email);\n // test returnAll()\n const updateReturns3 = await compilation.returnAll({}, updateValues1);\n expect(updateReturns3).toBeUndefined();\n // test returnCount()",
"score": 0.9029403924942017
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " const updateReturns2 = await compilation.returnOne({}, updateValues2);\n expect(updateReturns2?.id).toEqual(insertReturns[0].id);\n expect(updateReturns2?.h).toEqual(USERS[0].handle);\n const readUser2 = await userMapperReturningID\n .select({ id: insertReturns[0].id })\n .returnOne();\n expect(readUser2?.name).toEqual(updateValues2.name);\n expect(readUser2?.email).toEqual(updateValues2.email);\n // test returnAll()\n const updateReturns3 = await compilation.returnAll({}, updateValues1);",
"score": 0.9008493423461914
}
] | 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-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.9317163825035095
},
{
"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.9306693077087402
},
{
"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.9248644113540649
},
{
"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.9229658842086792
},
{
"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.9227694272994995
}
] | typescript | InsertedUser, columns) => { |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
| return SelectedUser.create(results.id, { |
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
| src/tests/insert-transforms.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 0.945896327495575
},
{
"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.9323410987854004
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " 'handle',\n 'email',\n ];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },",
"score": 0.9283164143562317
},
{
"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.9183768033981323
},
{
"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.9049358367919922
}
] | 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.9499964714050293
},
{
"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.8838262557983398
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;\n userMapperReturningID.update({ id: 32 }).returnOne(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }\n );\n // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;",
"score": 0.8813288807868958
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " userMapperReturningID.update({ id: 32 }).returnCount(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }\n );\n // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnCount(USERS[0]))[0].name;\n userMapperReturningID.update({ id: 32 }).run(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }",
"score": 0.845745325088501
},
{
"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.8206586241722107
}
] | 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.9091157913208008
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " });\n });\n it('accepts readonly parameters and updating objects', async () => {\n const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{\n id: number;\n }>(({ mapper, param }) =>\n mapper.update({ id: param('id') }).columns(['name'])\n );\n const params = { id: 1 as const } as const;\n const updateValues = {",
"score": 0.9011682271957397
},
{
"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.9010441899299622
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " notThere: 32,\n });\n // @ts-expect-error - only expected columns are returned\n insertReturn!.notThere;\n });\n });\n it('compiles an insert query with transformation', async () => {\n expect.assertions(7);\n const columnSubset: (keyof Insertable<Users>)[] = [\n 'name',",
"score": 0.8999819755554199
},
{
"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.8943531513214111
}
] | typescript | ({ mapper, param }) => mapper.select({ name: param('name') })
); |
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
let db: Kysely<Database>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('compiled updates', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: '[email protected]' };
const compilation = userMapperReturningID
.update({ id: 1 })
.columns(['email'])
.compile();
const success2 = await compilation.run({}, updateValues);
expect(success2).toBe(false);
const updateCount2 = await compilation.returnCount({}, updateValues);
expect(updateCount2).toEqual(0);
const updates2 = await compilation.returnAll({}, updateValues);
expect(updates2.length).toEqual(0);
const update2 = await compilation.returnOne({}, updateValues);
expect(update2).toBeNull();
});
it('compilations accept readonly updating objects', async () => {
const compilation = userMapperReturningNothing
.update('id', '=', 1)
.columns(['name', 'email'])
.compile();
const updateValues1 = {
name: 'Sue Rex' as const,
email: '[email protected]' as const,
} as const;
await compilation.run({}, updateValues1);
});
it('compiles a non-returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningNothing
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = {
name: 'Sue Rex' as const,
email: '[email protected]' as const,
} as const;
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = {
name: 'Johnny Rex' as const,
email: '[email protected]' as const,
} as const;
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2).toBeUndefined();
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3).toBeUndefined();
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
});
it('compiles a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningIDAndHandleAsH
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = { name: 'Sue Rex', email: '[email protected]' };
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex', email: '[email protected]' };
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2?.id).toEqual(insertReturns[0].id);
expect(updateReturns2?.h).toEqual(USERS[0].handle);
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3[0].id).toEqual(insertReturns[0].id);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
ignore('check compile-time types', () => {
compilation.returnOne(
{},
{
name: 'xyz',
handle: 'pdq',
email: '[email protected]',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
}
);
// @ts-expect-error - only expected columns are returned
updateReturns2!.handle;
// @ts-expect-error - only expected columns are returned
updateReturns3[0].handle;
});
});
it('accepts readonly parameters and updating objects', async () => {
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
const params = { id: 1 as const } as const;
const updateValues = {
name: 'Sue Rex' as const,
email: '[email protected]' as const,
} as const;
await parameterization.run(params, updateValues);
await parameterization.returnAll(params, updateValues);
await parameterization.returnOne(params, updateValues);
await parameterization.returnCount(params, updateValues);
});
it('parameterizes a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test run()
const updateValues1 = { name: 'Sue Rex' };
const updateReturns1 = await parameterization.run(
{ id: insertReturns[0].id },
updateValues1
);
expect(updateReturns1).toBe(true);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex' };
const updateReturns2 = await parameterization.returnOne(
{ id: insertReturns[1].id },
updateValues2
);
expect(updateReturns2?.id).toEqual(insertReturns[1].id);
expect(updateReturns2?.h).toEqual(USERS[1].handle);
// test returnAll()
const updateReturns3 = await parameterization.returnAll(
{ id: insertReturns[2].id },
updateValues1
);
expect(updateReturns3[0].id).toEqual(insertReturns[2].id);
expect(updateReturns3[0].h).toEqual(USERS[2].handle);
// verify updates
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers[0].name).toEqual(updateValues1.name);
expect(readUsers[1].name).toEqual(updateValues2.name);
expect(readUsers[2].name).toEqual(updateValues1.name);
// test returnCount()
const updateReturns4 = await parameterization.returnCount(
{ id: insertReturns[0].id },
updateValues2
);
expect(updateReturns4).toEqual(1);
const readUser = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid column names
updateReturns2!.handle;
// @ts-expect-error - errors on invalid column names
updateReturns3[0].handle;
userMapperReturningIDAndHandleAsH.parameterize<{ id: number }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, updateValues1);
parameterization.returnOne(
{ id: 1 },
{
name: 'xyz',
handle: 'pdq',
email: '[email protected]',
// @ts-expect-error - only updateable columns are allowed
notThere: 32,
}
);
});
});
it('compiles an update query with transformation', async () => {
expect.assertions(12);
const columnSubset: (keyof Updateable | <Users>)[] = ['name']; |
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
updateTransform: (source: User, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', '[email protected]');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', '[email protected]');
const user3 = new User(0, 'Sue', 'Rex', 'srex', '[email protected]');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const compilation = transformMapper
.update({ id: insertReturns[2].id })
.columns(columnSubset)
.compile();
// test returnOne()
const updateReturn1 = await compilation.returnOne({}, user1);
const expectedUser1 = User.create(insertReturns[2].id, {
firstName: user1.firstName,
lastName: user1.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn1).toEqual(expectedUser1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
const readUser1 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser1).toEqual(expectedUser1);
// test returnAll()
const updateReturn2 = await compilation.returnAll({}, user2);
const expectedUser2 = User.create(insertReturns[2].id, {
firstName: user2.firstName,
lastName: user2.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn2[0]).toEqual(expectedUser2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
const readUser2 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser2).toEqual(expectedUser2);
// test run()
const success1 = await compilation.run({}, user1);
expect(success1).toBe(true);
const readUser3 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser3).toEqual(expectedUser1);
// test returnCount()
const count = await compilation.returnCount({}, user2);
expect(count).toEqual(1);
const readUser4 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser4).toEqual(expectedUser2);
ignore('check compile-time types', async () => {
// @ts-expect-error - only update objects are allowed
compilation.returnOne({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnAll({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnCount({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.run({}, USERS[0]);
// @ts-expect-error - correct return is expected
(await compilation.returnOne({}, user1))!.name;
// @ts-expect-error - correct return is expected
(await compilation.returnAll({}, user2))[0].name;
});
});
it('parameterizes an update query with transformation', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['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) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
updateTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
updateReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', '[email protected]');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', '[email protected]');
const user3 = new User(0, 'Sue', 'Rex', 'srex', '[email protected]');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const parameterization = transformMapper.parameterize<{ id: number }>(
({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test returnOne()
const updateReturn1 = await parameterization.returnOne(
{ id: insertReturns[0].id },
user2
);
const expectedReturn1 = {
id: insertReturns[0].id,
firstName: user2.firstName,
lastName: user2.lastName,
};
expect(updateReturn1).toEqual(expectedReturn1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
// test returnAll()
const updateReturn2 = await parameterization.returnAll(
{ id: insertReturns[1].id },
user3
);
const expectedReturn2 = {
id: insertReturns[1].id,
firstName: user3.firstName,
lastName: user3.lastName,
};
expect(updateReturn2[0]).toEqual(expectedReturn2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
// test run()
const success1 = await parameterization.run(
{ id: insertReturns[2].id },
user1
);
const expectedReturn3 = {
id: insertReturns[2].id,
firstName: user1.firstName,
lastName: user1.lastName,
};
expect(success1).toBe(true);
// verify updates
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(expectedReturn1.id, {
...expectedReturn1,
handle: user1.handle,
email: user1.email!,
}),
User.create(expectedReturn2.id, {
...expectedReturn2,
handle: user2.handle,
email: user2.email!,
}),
User.create(expectedReturn3.id, {
...expectedReturn3,
handle: user3.handle,
email: user3.email!,
}),
]);
// test returnCount()
const count = await parameterization.returnCount(
{ id: insertReturns[2].id },
user2
);
expect(count).toEqual(1);
const readUser = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser).toEqual(
User.create(insertReturns[2].id, {
...expectedReturn1,
handle: user3.handle,
email: user3.email!,
})
);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid column names
updateReturn1!.handle;
// @ts-expect-error - errors on invalid column names
updateReturn2[0].handle;
transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, user1);
parameterization.returnOne(
{ id: 1 },
{
// @ts-expect-error - only updateable columns are allowed
name: 'xyz',
handle: 'pdq',
email: '[email protected]',
}
);
});
});
it('requires all indicated columns to be updated', async () => {
await userMapperReturningID.insert().run(USERS);
const compilation = userMapperReturningID
.update()
.columns(['name', 'handle', 'email'])
.compile();
const updateValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({}, { ...updateValues, email: null });
expect(success).toBe(true);
});
});
| src/tests/update-compile.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " notThere: 32,\n });\n // @ts-expect-error - only expected columns are returned\n insertReturn!.notThere;\n });\n });\n it('compiles an insert query with transformation', async () => {\n expect.assertions(7);\n const columnSubset: (keyof Insertable<Users>)[] = [\n 'name',",
"score": 0.9478899836540222
},
{
"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.8821021318435669
},
{
"filename": "src/tests/setting-types.test.ts",
"retrieved_chunk": " Updateable<Users>,\n number\n > {}\n new TestMapper(db, 'users', {\n // @ts-expect-error - invalid return count\n countTransform: (count: bigint) => BigInt(count),\n });\n });\n it('accepts readonly KeyColumns', () => {\n new TableMapper<",
"score": 0.88033527135849
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " // Ensure that returned objects can be accessed as expected.\n ((_: string) => {})(updateReturn!.name);\n ignore('type errors', () => {\n // @ts-expect-error - check return types\n insertReturn.name;\n // @ts-expect-error - check return types\n updateReturn!.id;\n });\n });\n it('inserts one configured to return all columns', async () => {",
"score": 0.868855357170105
},
{
"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.8685725927352905
}
] | typescript | <Users>)[] = ['name']; |
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createUserMapperReturningID } from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
beforeAll(async () => {
db = await createDB();
userMapperReturningID = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating specific columns', () => {
it('subsets updating columns, excluding ID', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { id: 100, name: 'Sue Rex', email: '[email protected]' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['name'] as const); // allows readonly array
const updateReturns = await subsetQuery.returnAll(updateValues);
expect(updateReturns).toEqual([{ id: insertReturns[0].id }]);
const readUsers = await userMapperReturningID
.select('id', '=', insertReturns[0].id)
.returnOne();
expect(readUsers).toEqual({
id: insertReturns[0].id,
name: 'Sue Rex',
email: USERS[0].email,
handle: USERS[0].handle,
});
});
it('subsets updating columns, including ID', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { id: 100, name: 'Sue Rex', email: '[email protected]' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['id', 'name', 'email']);
const updateReturns = await subsetQuery.returnAll(updateValues);
expect(updateReturns).toEqual([{ id: 100 }]);
const readUsers = await userMapperReturningID
.select('id', '=', 100)
.returnOne();
expect(readUsers).toEqual({
id: 100,
name: 'Sue Rex',
email: '[email protected]',
handle: USERS[0].handle,
});
});
it('requires all subsetted columns to be updated', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { name: 'Sue Rex' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email']);
expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await subsetQuery.run({ ...updateValues, email: null });
expect(success).toBe(true);
});
it('provides updateTransform with column subset', async () => {
expect.assertions(1);
| const mapper = new TableMapper(db, 'users').withTransforms({ |
updateTransform: (source, columns) => {
expect(columns).toEqual(['name', 'handle']);
return source;
},
});
await mapper.update().columns(['name', 'handle']).run({
name: 'John Doe',
handle: 'johndoe',
email: '[email protected]',
});
});
});
| src/tests/update-columns.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/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.9052590131759644
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " const count = await userMapper\n .delete({ name: USERS[0].name })\n .returnCount();\n expect(count).toEqual(0);\n const success = await userMapper.delete({ name: USERS[0].name }).run();\n expect(success).toEqual(false);\n });\n it('deletes rows without returning a count', async () => {\n const testMapper = new TableMapper(db, 'users').withTransforms({\n countTransform: (count) => Number(count),",
"score": 0.9041873812675476
},
{
"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.893764853477478
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(\n `column 'email' missing`\n );\n const success = await compilation.run({}, { ...updateValues, email: null });\n expect(success).toBe(true);\n });\n});",
"score": 0.8891360759735107
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " mapper.select(1);\n });\n });\n it('selects via a multi-column key tuple (different order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['name', 'id'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select(['Sue', 3]).returnAll();\n expect(users.length).toEqual(1);",
"score": 0.8876805305480957
}
] | typescript | const mapper = new TableMapper(db, 'users').withTransforms({ |
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { User } from './utils/test-types';
import { ignore } from './utils/test-utils';
import { createInsertTransformMapper } from './utils/test-mappers';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper transform type checks', () => {
ignore('detects invalid select transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid select transform
selectTransform: (user: User) => user,
});
});
ignore('detects invalid insert transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid insert transform
insertTransform: (user: User) => user,
});
});
ignore('detects invalid update transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid update transform
updateTransform: (_user) => ({ noId: 1 }),
});
});
ignore('detects invalid update return transform return', async () => {
const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });
mapper.withTransforms({
selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', '[email protected]'),
updateTransform: (user: User) => ({
id: user.id,
name: `${user.firstName} ${user.lastName}`,
handle: user.handle,
email: user.email,
}),
| updateReturnTransform: (_user, returns) => returns,
}); |
(await mapper
.update({ id: 1 })
// @ts-expect-error - ensure that return type is User
.returnOne(new User(1, 'John', 'Doe', 'jdoe', '[email protected]')))!.name;
});
ignore('detects insertion transformation type errors', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(selectedUser1);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(selectedUser1);
});
it('accepts readonly transforms', () => {
const transforms = {
countTransform: (count: bigint) => count,
} as const;
new TableMapper(db, 'users', {}).withTransforms(transforms);
});
});
| src/tests/transform-types.test.ts | jtlapp-kysely-mapper-9fd878b | [
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " 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.9279851913452148
},
{
"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.9101385474205017
},
{
"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.9085572957992554
},
{
"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.9044539928436279
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n insertReturnTransform: (source: User, returns) => ({\n id: returns.id,\n firstName: source.firstName,\n lastName: source.lastName,\n }),\n updateTransform: (source: User) => ({",
"score": 0.9040600657463074
}
] | typescript | updateReturnTransform: (_user, returns) => returns,
}); |
/**
* 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.9447472095489502
},
{
"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.8959503769874573
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;\n userMapperReturningID.update({ id: 32 }).returnOne(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }\n );\n // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;",
"score": 0.8777205944061279
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " userMapperReturningID.update({ id: 32 }).returnCount(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }\n );\n // @ts-expect-error - only requested columns are accessible\n // prettier-ignore\n (await userMapperReturningID.update({ id: 32 }).returnCount(USERS[0]))[0].name;\n userMapperReturningID.update({ id: 32 }).run(\n // @ts-expect-error - update must only have table columns\n { notThere: '[email protected]' }",
"score": 0.8470603823661804
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " { notThere: 'xyz' }\n );\n // @ts-expect-error - table must have all filter fields\n userMapperReturningID.update('notThere', '=', 'foo');\n userMapperReturningID.update(({ or, cmpr }) =>\n // @ts-expect-error - only table columns are accessible via anyOf()\n or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])\n );\n // @ts-expect-error - ID filter must have correct type\n userMapperReturningID.update('str');",
"score": 0.8290743827819824
}
] | typescript | .select((qb) => qb)
.returnOne()
// @ts-expect-error - only table columns are accessible w/ QB filter
)!.notThere; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.