akanjs 0.0.1 → 2.0.0-beta.0

package/dictionary/dictionary.ts

@@ -0,0 +1,10 @@
+import type { BaseEndpoint } from "akanjs/signal";
+
+import { baseDictionary } from "./base.dictionary";
+import { registerServiceTrans } from "./locale";
+import { makeTrans } from "./trans";
+
+export const dictionary = { base: registerServiceTrans<"base", BaseEndpoint, typeof baseDictionary>(baseDictionary) };
+
+export const { Err, translate, msg, getDictionary, getAllDictionary, __Dict_Key__, __Error_Key__ } =
+  makeTrans(dictionary);

package/dictionary/index.ts

@@ -0,0 +1,12 @@
+export * from "./dictInfo";
+export {
+  __Dict_Key__,
+  __Error_Key__,
+  dictionary,
+  Err,
+  getAllDictionary,
+  getDictionary,
+  translate,
+} from "./dictionary";
+export * from "./locale";
+export * from "./trans";

package/dictionary/locale.ts

@@ -0,0 +1,230 @@
+import type { GetStateObject, MergedValues } from "akanjs/base";
+import type { BaseInsight, BaseObject } from "akanjs/constant";
+import type { FilterInfo, FilterInstance } from "akanjs/document";
+import type { EndpointInfo, SliceInfo } from "akanjs/signal";
+import type { ModelDictInfo, ScalarDictInfo, ServiceDictInfo } from ".";
+
+interface Trans {
+  t: string;
+}
+interface FieldTrans {
+  t: string;
+  desc?: string;
+}
+interface FnTrans<ArgKey extends string> {
+  t: string;
+  desc?: string;
+  arg?: { [key in ArgKey]: FieldTrans };
+}
+type FilterTranslatorKey<Filter extends FilterInstance> = {
+  [Key in keyof Filter["query"] & string]:
+    | `${Key}`
+    | `${Key}.desc`
+    | (Filter["query"][Key] extends FilterInfo<infer ArgNames, any>
+        ? ArgNames[number] extends string
+          ? `${Key}.arg.${ArgNames[number]}` | `${Key}.arg.${ArgNames[number]}.desc`
+          : never
+        : never);
+}[keyof Filter["query"] & string];
+type EndpointTranslatorKey<Endpoint extends { [key: string]: EndpointInfo }> = {
+  [Key in keyof Endpoint & string]:
+    | `${Key}`
+    | `${Key}.desc`
+    | `${Key}.arg.${Endpoint[Key]["argNames"][number]}`
+    | `${Key}.arg.${Endpoint[Key]["argNames"][number]}.desc`;
+}[keyof Endpoint & string];
+type SliceTranslatorKey<Slice> = {
+  [Key in keyof Slice & string]: Slice[Key] extends SliceInfo<
+    infer T,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer ArgNames,
+    any,
+    any,
+    any
+  >
+    ?
+        | `${T}List${Capitalize<Key>}`
+        | `${T}List${Capitalize<Key>}.desc`
+        | `${T}List${Capitalize<Key>}.arg.${ArgNames[number] | "skip" | "limit" | "sort"}`
+        | `${T}List${Capitalize<Key>}.arg.${ArgNames[number] | "skip" | "limit" | "sort"}.desc`
+        | `${T}Insight${Capitalize<Key>}`
+        | `${T}Insight${Capitalize<Key>}.desc`
+        | `${T}Insight${Capitalize<Key>}.arg.${ArgNames[number]}`
+        | `${T}Insight${Capitalize<Key>}.arg.${ArgNames[number]}.desc`
+    : never;
+}[keyof Slice & string];
+
+type SliceApiTrans<
+  T extends string,
+  Suffix extends string,
+  ArgName extends string,
+  _CapitalizedSuffix extends string = Capitalize<Suffix>,
+> = {
+  [K in `${T}List${_CapitalizedSuffix}`]: FnTrans<ArgName | "skip" | "limit" | "sort">;
+} & {
+  [K in `${T}Insight${_CapitalizedSuffix}`]: FnTrans<ArgName>;
+};
+type BaseModelCrudGetApiTrans<T extends string> = {
+  [K in T]: FnTrans<`${T}Id`>;
+} & {
+  [K in `light${T}`]: FnTrans<`${T}Id`>;
+} & {
+  [K in `create${T}`]: FnTrans<"data">;
+} & {
+  [K in `update${T}`]: FnTrans<`${T}Id` | "data">;
+} & {
+  [K in `remove${T}`]: FnTrans<`${T}Id`>;
+};
+
+export type ModelTrans<
+  T extends string,
+  Model extends BaseObject,
+  Insight extends BaseInsight,
+  Filter extends FilterInstance,
+  Slice extends { [key: string]: SliceInfo },
+  Endpoint extends { [key: string]: EndpointInfo },
+  ErrorKey extends string,
+  EtcKey extends string,
+> = {
+  modelName: Trans;
+  modelDesc: Trans;
+  model: { [K in keyof GetStateObject<Model>]: FieldTrans };
+  insight: { [K in keyof GetStateObject<Insight>]: FieldTrans };
+  query: {
+    [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<infer ArgNames, any>
+      ? FnTrans<ArgNames[number]>
+      : never;
+  };
+  sort: { [K in keyof Filter["sort"]]: FieldTrans };
+  api: {
+    [K in keyof Endpoint]: FnTrans<Endpoint[K]["argNames"][number]>;
+  } & BaseModelCrudGetApiTrans<T> &
+    MergedValues<{
+      [K in keyof Slice]: SliceApiTrans<Slice[K]["refName"], K & string, Slice[K]["argNames"][number]>;
+    }>;
+  error: { [K in ErrorKey]: Trans };
+} & { [K in EtcKey]: Trans };
+export type ModelTranslatorKey<
+  T extends string,
+  Model,
+  Insight,
+  Filter extends FilterInstance,
+  Slice extends { [key: string]: SliceInfo },
+  Endpoint extends { [key: string]: EndpointInfo },
+  EtcKey extends string,
+> =
+  | `${T}.modelName`
+  | `${T}.modelDesc`
+  | `${T}.${keyof GetStateObject<Model> & string}${"" | ".desc"}`
+  | `${T}.insight.${keyof GetStateObject<Insight> & string}${"" | ".desc"}`
+  | `${T}.query.${FilterTranslatorKey<Filter>}`
+  | `${T}.sort.${keyof Filter["sort"] & string}${"" | ".desc"}`
+  | `${T}.signal.${EndpointTranslatorKey<Endpoint> | SliceTranslatorKey<Slice>}`
+  | `${T}.${EtcKey}`;
+
+export type ScalarTrans<T extends string, Model, ErrorKey extends string, EtcKey extends string> = {
+  name: Trans;
+  desc: Trans;
+  model: { [K in keyof GetStateObject<Model>]: FieldTrans };
+  error: { [K in ErrorKey]: Trans };
+} & { [K in EtcKey]: Trans };
+export type ScalarTranslatorKey<T extends string, Model, EtcKey extends string> =
+  | `${T}.modelName`
+  | `${T}.modelDesc`
+  | `${T}.${keyof GetStateObject<Model> & string}${"" | ".desc"}`
+  | `${T}.${EtcKey}`;
+
+export type ServiceTrans<
+  T extends string,
+  Endpoint extends { [key: string]: EndpointInfo },
+  ErrorKey extends string,
+  EtcKey extends string,
+> = {
+  api: {
+    [K in keyof Endpoint]: FnTrans<Endpoint[K]["argNames"][number]>;
+  };
+  error: { [K in ErrorKey]: Trans };
+} & { [K in EtcKey]: Trans };
+export type ServiceTranslatorKey<
+  T extends string,
+  Endpoint extends { [key: string]: EndpointInfo },
+  EtcKey extends string,
+> = `${T}.signal.${EndpointTranslatorKey<Endpoint>}` | `${T}.${EtcKey}`;
+
+export type EnumTrans<EnumValue extends string | number> = {
+  [key in EnumValue]: Trans;
+};
+export type EnumTranslatorKey<EnumKey extends string> = `${EnumKey}.${string}${"" | ".desc"}`;
+
+export interface DictModule<DictKey extends string, ErrorKey extends string> {
+  __Dict_Key__: DictKey;
+  __Error_Key__: ErrorKey;
+  dict: ModelDictInfo<any> | ScalarDictInfo<any> | ServiceDictInfo<any>;
+}
+
+export const registerModelTrans = <
+  RefName extends string,
+  Model extends BaseObject,
+  Insight extends BaseInsight,
+  Filter extends FilterInstance,
+  Slice extends { [key: string]: SliceInfo },
+  Endpoint extends { [key: string]: EndpointInfo },
+  ModelDict extends ModelDictInfo<any>,
+>(
+  modelDict: ModelDict,
+): ModelDict extends ModelDictInfo<any, any, any, any, any, infer EnumKey, any, any, any, infer ErrorKey, infer EtcKey>
+  ? DictModule<
+      ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
+      `${RefName}.error.${ErrorKey}`
+    >
+  : never => {
+  return { dict: modelDict } as unknown as ModelDict extends ModelDictInfo<
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer EnumKey,
+    any,
+    any,
+    any,
+    infer ErrorKey,
+    infer EtcKey
+  >
+    ? DictModule<
+        ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
+        `${RefName}.error.${ErrorKey}`
+      >
+    : never;
+};
+
+export const registerScalarTrans = <T extends string, Model, ScalarDict>(
+  scalarDict: ScalarDict,
+): ScalarDict extends ScalarDictInfo<any, any, infer EnumKey, infer ErrorKey, infer EtcKey>
+  ? DictModule<ScalarTranslatorKey<T, Model, EtcKey> | EnumTranslatorKey<EnumKey>, `${T}.error.${ErrorKey}`>
+  : never => {
+  return { dict: scalarDict } as unknown as ScalarDict extends ScalarDictInfo<
+    any,
+    any,
+    infer EnumKey,
+    infer ErrorKey,
+    infer EtcKey
+  >
+    ? DictModule<ScalarTranslatorKey<T, Model, EtcKey> | EnumTranslatorKey<EnumKey>, `${T}.error.${ErrorKey}`>
+    : never;
+};
+
+export const registerServiceTrans = <T extends string, Endpoint extends { [key: string]: EndpointInfo }, ServiceDict>(
+  serviceDict: ServiceDict,
+): ServiceDict extends ServiceDictInfo<any, any, infer ErrorKey, infer EtcKey>
+  ? DictModule<ServiceTranslatorKey<T, Endpoint, EtcKey>, `${T}.error.${ErrorKey}`>
+  : never => {
+  return { dict: serviceDict } as unknown as ServiceDict extends ServiceDictInfo<any, any, infer ErrorKey, infer EtcKey>
+    ? DictModule<ServiceTranslatorKey<T, Endpoint, EtcKey>, `${T}.error.${ErrorKey}`>
+    : never;
+};

package/dictionary/trans.ts

@@ -0,0 +1,196 @@
+import type { GetStateObject, ObjectAssign, Prettify } from "akanjs/base";
+import { pathGet } from "akanjs/common";
+
+import type { DictModule } from "./locale";
+
+type TranslationSingle = readonly [string, string] | readonly [string, string, string, string];
+type TranslationWithParam = readonly [string, string, { [key: string]: string | number }];
+export type Translation = TranslationSingle | TranslationWithParam;
+export type TranslationData = Record<string, unknown>;
+export type DictionaryNode = Record<string, unknown>;
+export type RootDictionary = Record<string, Record<string, DictionaryNode>>;
+
+export type Translate<Checker> = {
+  [K in keyof GetStateObject<Checker>]: Translation;
+} & Record<string, Translation> & { modelName: Translation };
+
+export type TransMessage<Locale extends Record<string, unknown>> = {
+  [K in keyof Locale]-?: `${K & string}${Locale[K] extends Record<string, unknown> ? `.${keyof Locale[K] extends string ? keyof Locale[K] : never}` : ""}`;
+}[keyof Locale];
+
+export const makeDictionary = <Dicts extends Record<string, unknown>[]>(
+  ...dicts: Dicts
+): Prettify<ObjectAssign<Dicts>> => {
+  return Object.assign(...(dicts as unknown as [object, object])) as Prettify<ObjectAssign<Dicts>>;
+};
+
+const languages = ["en", "ko", "zhChs", "zhCht", "ja"] as const;
+
+type Language = (typeof languages)[number];
+export interface TransMessageOption {
+  key?: string;
+  duration?: number;
+  data?: TranslationData;
+}
+
+export interface ErrRestoreOption {
+  statusCode?: number;
+  details?: unknown;
+  path?: string;
+  timestamp?: string;
+}
+
+export interface ErrPayload extends ErrRestoreOption {
+  error: string;
+  data?: TranslationData;
+}
+
+export type ErrInstance = Error & {
+  readonly error: string;
+  readonly statusCode: number;
+  readonly details?: unknown;
+  readonly data?: TranslationData;
+  readonly path?: string;
+  readonly timestamp?: string;
+  toJSON(): ErrPayload & { statusCode: number };
+};
+
+export type ErrConstructor<ErrorKey extends string> = {
+  new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption): ErrInstance;
+  prototype: ErrInstance;
+  fromJSON(payload: ErrPayload): ErrInstance;
+  BadRequest: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+  Unauthorized: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+  Forbidden: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+  NotFound: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+  Conflict: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+};
+
+export const msg = {
+  info: () => null,
+  success: () => null,
+  error: () => null,
+  warning: () => null,
+  loading: () => null,
+} as {
+  info: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+  success: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+  error: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+  warning: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+  loading: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+};
+
+const rootDictionary = {} as RootDictionary;
+export const makeTrans = <
+  GlobalTransMap extends Record<string, DictModule<string, string>>,
+  _DictKey extends string = GlobalTransMap[keyof GlobalTransMap]["__Dict_Key__"],
+  _ErrorKey extends string = GlobalTransMap[keyof GlobalTransMap]["__Error_Key__"],
+>(
+  transMap: GlobalTransMap,
+  { build = false }: { build?: boolean } = {},
+): {
+  Err: ErrConstructor<_ErrorKey>;
+  translate: (lang: Language, key: _DictKey, data?: TranslationData) => string;
+  msg: {
+    info: (key: _DictKey, option?: TransMessageOption) => void;
+    success: (key: _DictKey, option?: TransMessageOption) => void;
+    error: (key: _DictKey, option?: TransMessageOption) => void;
+    warning: (key: _DictKey, option?: TransMessageOption) => void;
+    loading: (key: _DictKey, option?: TransMessageOption) => void;
+  };
+  getDictionary: (lang: Language) => object;
+  getAllDictionary: () => RootDictionary;
+  __Dict_Key__: _DictKey;
+  __Error_Key__: _ErrorKey;
+} => {
+  Object.entries(transMap).forEach(([refName, trans]) => {
+    trans.dict._registerToRoot(refName, rootDictionary);
+  });
+  class Err extends Error {
+    readonly error: string;
+    readonly statusCode: number;
+    readonly details?: unknown;
+    readonly data?: TranslationData;
+    readonly path?: string;
+    readonly timestamp?: string;
+
+    constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
+      super(key as string);
+      this.name = this.constructor.name;
+      this.error = key as string;
+      this.statusCode = option.statusCode ?? 400;
+      this.details = option.details;
+      this.data = data;
+      this.path = option.path;
+      this.timestamp = option.timestamp;
+    }
+
+    toJSON() {
+      return {
+        error: this.message,
+        statusCode: this.statusCode,
+        ...(this.details !== undefined ? { details: this.details } : {}),
+        ...(this.data !== undefined ? { data: this.data } : {}),
+        ...(this.path !== undefined ? { path: this.path } : {}),
+        ...(this.timestamp !== undefined ? { timestamp: this.timestamp } : {}),
+      };
+    }
+
+    static fromJSON(payload: ErrPayload) {
+      return new Err(payload.error as _ErrorKey, payload.data, payload);
+    }
+
+    static BadRequest = class BadRequestErr extends Err {
+      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
+        super(key, data, { ...option, statusCode: 400 });
+      }
+    };
+
+    static Unauthorized = class UnauthorizedErr extends Err {
+      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
+        super(key, data, { ...option, statusCode: 401 });
+      }
+    };
+
+    static Forbidden = class ForbiddenErr extends Err {
+      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
+        super(key, data, { ...option, statusCode: 403 });
+      }
+    };
+
+    static NotFound = class NotFoundErr extends Err {
+      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
+        super(key, data, { ...option, statusCode: 404 });
+      }
+    };
+
+    static Conflict = class ConflictErr extends Err {
+      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
+        super(key, data, { ...option, statusCode: 409 });
+      }
+    };
+  }
+  const translate = (lang: Language, key: _DictKey, data?: TranslationData) => {
+    const [modelName, ...msgKeys] = key.split(".");
+    const msgKey = msgKeys.join(".");
+    const langDict = rootDictionary[lang] ?? {};
+    const model = langDict[modelName as string] ?? {};
+    const message = pathGet(msgKey as string, model, ".", { t: key }) as { t: string };
+    return message.t;
+  };
+  const getDictionary = (lang: Language) => {
+    return rootDictionary[lang];
+  };
+  const getAllDictionary = () => {
+    return rootDictionary;
+  };
+  return {
+    Err,
+    translate,
+    msg,
+    getDictionary,
+    getAllDictionary,
+    __Dict_Key__: null as unknown as _DictKey,
+    __Error_Key__: null as unknown as _ErrorKey,
+  };
+};

package/document/by.ts

@@ -0,0 +1,39 @@
+import { type Cls, FIELD_META, type MergeAllActionTypes, type UnCls } from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import {
+  type BaseObject,
+  type ConstantCls,
+  ConstantRegistry,
+  type DocumentModel,
+  type FieldObject,
+} from "akanjs/constant";
+
+export type DatabaseCls<Schema = any> = Cls<Schema, { refName: string; [FIELD_META]: FieldObject }>;
+
+export interface DefaultDocMtds<TDocument> {
+  refresh(): Promise<this>;
+  isModified(field?: keyof TDocument & string): boolean;
+  set(data: Partial<TDocument>): this;
+  save(): Promise<this>;
+  toJSON(): DocumentModel<TDocument>;
+  toObject(): DocumentModel<TDocument>;
+}
+type HydratedDocumentWithId<TDocument> = TDocument & { id: string } & DefaultDocMtds<TDocument>;
+export type Doc<M = any> = HydratedDocumentWithId<DocumentModel<M>>;
+
+export const by = <
+  ModelCls,
+  AddDbModels extends DatabaseCls[],
+  _DocModel = UnCls<ModelCls> extends BaseObject ? Doc<UnCls<ModelCls>> : DocumentModel<UnCls<ModelCls>>,
+>(
+  modelRef: ModelCls,
+  ...addRefs: AddDbModels
+): DatabaseCls<MergeAllActionTypes<AddDbModels, keyof _DocModel & string> & _DocModel> => {
+  const refName = ConstantRegistry.getRefName(modelRef as Cls);
+  const databaseCls = class DatabaseCls {
+    static refName = refName;
+    static [FIELD_META] = (modelRef as ConstantCls)[FIELD_META];
+  };
+  applyMixins(databaseCls as Cls, addRefs);
+  return databaseCls as any;
+};

package/document/dataLoader.ts

@@ -0,0 +1,91 @@
+import type { QueryOf } from "akanjs/constant";
+import DataLoader from "dataloader";
+import { get, groupBy, keyBy } from "lodash";
+
+export const Id = String;
+export const ObjectId = String;
+export const Mixed = Object;
+export { DataLoader };
+
+type LoaderItem = Record<string, unknown>;
+type LoaderModel = {
+  find: (query: QueryOf<unknown>) => Promise<LoaderItem[]> | { then: Promise<LoaderItem[]>["then"] };
+};
+type ArrayElementLoaderItem = LoaderItem & { key: unknown };
+type QueryRecord = Record<string, unknown>;
+
+const setQueryOperator = (query: QueryOf<unknown>, fieldName: string, op: "oneOf" | "has", value: unknown) => {
+  (query as QueryRecord)[fieldName] = { kind: "op", op, value };
+};
+
+export const createLoader = <Key, Value>(model: LoaderModel, fieldName = "id", defaultQuery: QueryOf<unknown> = {}) => {
+  return new DataLoader<Key, Value>(
+    (fields) => {
+      const query: QueryOf<unknown> = { ...defaultQuery };
+      setQueryOperator(query, fieldName, "oneOf", fields);
+      const data = Promise.resolve(model.find(query)).then((list) => {
+        const listByKey = keyBy(list, fieldName);
+        return fields.map((id: unknown) => get(listByKey, String(id), null));
+      });
+      return data as unknown as Promise<Value[]>;
+    },
+    { name: "dataloader", cache: false },
+  );
+};
+export const createArrayLoader = <K, V>(model: LoaderModel, fieldName = "id", defaultQuery: QueryOf<unknown> = {}) => {
+  return new DataLoader<K, V>((fields) => {
+    const query: QueryOf<unknown> = { ...defaultQuery };
+    setQueryOperator(query, fieldName, "has", fields);
+    const data = Promise.resolve(model.find(query)).then((list) => {
+      return fields.map((field) => list.filter((item) => field === item[fieldName]));
+    });
+    return data as unknown as Promise<V[]>;
+  });
+};
+export const createArrayElementLoader = <K, V>(
+  model: LoaderModel,
+  fieldName = "id",
+  defaultQuery: QueryOf<unknown> = {},
+) => {
+  return new DataLoader<K, V>(
+    (fields) => {
+      const query: QueryOf<unknown> = { ...defaultQuery };
+      setQueryOperator(query, fieldName, "oneOf", fields);
+      const data = Promise.resolve(model.find(query)).then((list) => {
+        const flat: ArrayElementLoaderItem[] = list.flatMap((datum) => {
+          const values = Array.isArray(datum[fieldName]) ? datum[fieldName] : [];
+          return values.map((datField: unknown) => ({
+            ...datum,
+            key: datField,
+          }));
+        });
+        const listByKey = groupBy(flat, (dat) => dat.key);
+        return fields.map((id) => get(listByKey, String(id), null));
+      });
+      return data as unknown as Promise<V[]>;
+    },
+    { name: "dataloader", cache: false },
+  );
+};
+
+export const createQueryLoader = <Key, Value>(
+  model: LoaderModel,
+  queryKeys: string[],
+  defaultQuery: QueryOf<unknown> = {},
+) => {
+  return new DataLoader<Key, Value, Key>(
+    (queries) => {
+      const query = { kind: "all", queries: [{ kind: "any", queries }, defaultQuery] } as QueryOf<unknown>;
+      const getQueryKey = (query: QueryOf<unknown>) =>
+        queryKeys.map((key) => String((query as QueryRecord)[key])).join("");
+      const data = Promise.resolve(model.find(query)).then((list) => {
+        const listByKey = keyBy(list, getQueryKey);
+        return queries.map((query: QueryOf<unknown>) => get(listByKey, getQueryKey(query), null));
+      });
+      return data as unknown as Promise<Value[]>;
+    },
+    { name: "dataloader", cache: false },
+  );
+};
+
+export type Loader<Field, Value> = DataLoader<Field, Value | null>;