Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | 6x 6x 6x | import { hashKey } from "@tanstack/react-query";
import { TRPCError } from "@trpc/server";
import { omit, unique, values } from "remeda";
export const getDuplicates = <T, K extends string | string[]>(
array: readonly T[],
getKey: (item: T) => K,
) => {
const items = array.map(getKey);
const map = new Map<string, { count: number; value: K }>();
for (const item of items) {
const key = Array.isArray(item) ? item.join("|") : (item satisfies string);
const prevMapElement = map.get(key) || {
count: 0,
value: item,
};
map.set(key, {
count: prevMapElement.count + 1,
value: prevMapElement.value,
});
}
return [...map.values()]
.filter(({ count }) => count !== 1)
.map(({ value, count }) => [value, count] as const);
};
export type GeneralInput = { cursor: number; limit: number };
export type GeneralOutput<T> = { cursor: number; items: T[] };
const mergeInputs = <I extends GeneralInput>(inputs: I[]): Map<I, I> => {
const sorted = [...inputs].toSorted((a, b) => a.cursor - b.cursor);
const groups = sorted.reduce<(I & { members: I[] })[]>((acc, element) => {
const lastGroup = acc.at(-1);
if (!lastGroup || element.cursor > lastGroup.cursor + lastGroup.limit) {
return [...acc, { ...element, members: [element] }];
}
return [
...acc.slice(0, -1),
{
...lastGroup,
limit:
Math.max(
lastGroup.cursor + lastGroup.limit,
element.cursor + element.limit,
) - lastGroup.cursor,
members: [...lastGroup.members, element],
},
];
}, []);
return new Map<I, I>(
groups.flatMap(({ members, ...group }) =>
members.map((member) => [member, group as unknown as I]),
),
);
};
export const queueList = async <
I extends GeneralInput,
R,
O extends GeneralOutput<R>,
>(
inputs: readonly I[],
fetchPage: (inputs: I) => Promise<O>,
): Promise<(O | TRPCError)[]> => {
const mappedInputs = inputs.reduce<Partial<Record<string, I[]>>>(
(acc, input) => {
const key = hashKey([omit(input, ["cursor", "limit"])]);
return { ...acc, [key]: [...(acc[key] ?? []), input] };
},
{},
);
const compactInputsMap = new Map<I, I>(
values(mappedInputs).flatMap((mappedInput = []) => {
const compactInput = mergeInputs(mappedInput);
return mappedInput.map(
// oxlint-disable-next-line typescript/no-non-null-assertion
(input) => [input, compactInput.get(input)!],
);
}),
);
const compactInputs = unique([...compactInputsMap.values()]);
const list = await Promise.all(
compactInputs.map(async (input) =>
fetchPage(input).catch(
(error) =>
/* c8 ignore start */
error instanceof TRPCError
? error
: new TRPCError({
code: "INTERNAL_SERVER_ERROR",
message: `Unknown internal error: ${String(error)}`,
cause: error,
}),
/* c8 ignore stop */
),
),
);
const mappedList = new Map<I, O | TRPCError>(
// oxlint-disable-next-line typescript/no-non-null-assertion
compactInputs.map((input, index) => [input, list[index]!]),
);
return inputs.map((input) => {
const mappedInput = compactInputsMap.get(input);
/* c8 ignore start */
if (!mappedInput) {
return new TRPCError({
code: "INTERNAL_SERVER_ERROR",
message: `Expected for input "${JSON.stringify(input)}" to have corresponding compact input.`,
});
}
/* c8 ignore stop */
const output = mappedList.get(mappedInput);
if (output instanceof TRPCError) {
return output;
}
/* c8 ignore start */
if (!output) {
return new TRPCError({
code: "INTERNAL_SERVER_ERROR",
message: `Expected for compact input "${JSON.stringify(mappedInput)}" to have corresponding output.`,
});
}
/* c8 ignore stop */
const startIndex = input.cursor - output.cursor;
return {
...output,
cursor: input.cursor,
items: output.items.slice(startIndex, startIndex + input.limit),
};
});
};
|