akanjs 2.0.5 → 2.0.7

package/devkit/capacitorApp.ts

@@ -15,37 +15,53 @@ interface RunConfig {
   regenerate?: boolean;
 }
 
+interface PrepareConfig extends RunConfig {}
+
 export class CapacitorApp {
   project: MobileProject & { ios: IosProject; android: AndroidProject };
   iosTargetName = "App";
   readonly targetRoot: string;
+  readonly targetRootPath: string;
+  readonly targetWebRoot: string;
+  readonly targetAssetRoot: string;
+  readonly iosRootPath = "ios";
+  readonly iosProjectPath = "ios/App";
+  readonly androidRootPath = "android";
   constructor(
     private readonly app: AppExecutor,
     readonly target: AkanMobileTargetConfig,
   ) {
-    this.targetRoot = path.join(this.app.cwdPath, "mobile", this.target.name);
-    this.project = new MobileProject(this.targetRoot, {
-      android: { path: "android" },
-      ios: { path: "ios/App" },
+    this.targetRootPath = path.posix.join("mobile", this.target.name);
+    this.targetRoot = path.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path.join(this.targetRoot, "www");
+    this.targetAssetRoot = path.join(this.targetRoot, "assets");
+    this.project = new MobileProject(this.app.cwdPath, {
+      android: { path: this.androidRootPath },
+      ios: { path: this.iosProjectPath },
     }) as MobileProject & { ios: IosProject; android: AndroidProject };
   }
-  async init({ platform, regenerate = false }: { platform?: "ios" | "android"; regenerate?: boolean } = {}) {
+  async init({
+    platform,
+    operation = "release",
+    env = "debug",
+    regenerate = false,
+  }: { platform?: "ios" | "android" } & Partial<PrepareConfig> = {}) {
     await mkdir(this.targetRoot, { recursive: true });
     await this.#writeCapacitorConfig();
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm(path.join(this.targetRoot, "ios"), { recursive: true, force: true });
+        await rm(path.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm(path.join(this.targetRoot, "android"), { recursive: true, force: true });
+        await rm(path.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project as MobileProject;
     await this.project.load();
     if ((!platform || platform === "android") && !project.android) {
-      await this.#spawn("npx", ["cap", "add", "android"]);
+      await this.#spawnMobile("npx", ["cap", "add", "android"], { operation, env });
       await this.project.load();
     }
     if ((!platform || platform === "ios") && !project.ios) {
-      await this.#spawn("npx", ["cap", "add", "ios"]);
+      await this.#spawnMobile("npx", ["cap", "add", "ios"], { operation, env });
       await this.project.load();
     }
     return this;
@@ -53,58 +69,54 @@ export class CapacitorApp {
   async save() {
     await this.project.commit();
   }
-  async #prepareIos({ regenerate = false }: { regenerate?: boolean } = {}) {
-    await this.init({ platform: "ios", regenerate });
+  async #prepareIos({ operation, env, regenerate = false }: PrepareConfig) {
+    await this.init({ platform: "ios", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("ios");
     await this.#applyIosMetadata();
     await this.#applyPermissions();
     await this.#applyLinks();
     await this.project.commit();
-    await this.#generateAssets();
+    await this.#generateAssets({ operation, env });
     this.app.verbose(`syncing iOS`);
-    await this.#spawn("npx", ["cap", "sync", "ios"]);
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env });
     this.app.verbose(`sync completed.`);
   }
-  async buildIos(options: { regenerate?: boolean } = {}) {
+  async buildIos({ env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {}) {
     await this.prepareWww();
-    await this.#prepareIos(options);
-    await this.#spawn("npx", ["cap", "build", "ios"], { stdio: "inherit" });
+    await this.#prepareIos({ operation: "release", env, regenerate });
+    await this.#spawnMobile("npx", ["cap", "build", "ios"], { operation: "release", env }, { stdio: "inherit" });
     this.app.verbose(`build completed iOS.`);
     return;
   }
   async syncIos() {
-    await this.#spawn("npx", ["cap", "sync", "ios"]);
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation: "local", env: "local" });
   }
   async openIos() {
-    await this.#spawn("npx", ["cap", "open", "ios"]);
+    await this.#spawnMobile("npx", ["cap", "open", "ios"], { operation: "local", env: "local" });
   }
   async runIos({ operation, env, regenerate = false }: RunConfig) {
     if (operation === "release") await this.prepareWww();
-    await this.#prepareIos({ regenerate });
+    await this.#prepareIos({ operation, env, regenerate });
     const args = ["cap", "run", "ios"];
-    if (operation !== "release") args.push("--live-reload");
-    await this.#spawn("npx", args, {
-      env: this.#commandEnv(operation, env),
-      stdio: "inherit",
-    });
+    await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
 
-  async #prepareAndroid({ regenerate = false }: { regenerate?: boolean } = {}) {
-    await this.init({ platform: "android", regenerate });
+  async #prepareAndroid({ operation, env, regenerate = false }: PrepareConfig) {
+    await this.init({ platform: "android", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("android");
     await this.#applyAndroidMetadata();
     await this.#applyPermissions();
     await this.#applyLinks();
     await this.project.commit();
-    await this.#generateAssets();
-    await this.#spawn("npx", ["cap", "sync", "android"]);
+    await this.#generateAssets({ operation, env });
+    await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
 
   async #updateAndroidBuildTypes() {
 
-    const appGradle = await FileEditor.create(`${this.targetRoot}/android/app/build.gradle`);
+    const appGradle = await FileEditor.create(path.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -139,9 +151,12 @@ export class CapacitorApp {
     }
     await appGradle.save();
   }
-  async buildAndroid(assembleType: "apk" | "aab", options: { regenerate?: boolean } = {}) {
+  async buildAndroid(
+    assembleType: "apk" | "aab",
+    { env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {},
+  ) {
     await this.prepareWww();
-    await this.#prepareAndroid(options);
+    await this.#prepareAndroid({ operation: "release", env, regenerate });
     await this.#updateAndroidBuildTypes();
     
     const isWindows = process.platform === "win32";
@@ -149,45 +164,44 @@ export class CapacitorApp {
 
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: `${this.targetRoot}/android`,
+      cwd: path.join(this.app.cwdPath, this.androidRootPath),
+      env: this.#commandEnv("release", env),
     });
   }
   async openAndroid() {
-    await this.#spawn("npx", ["cap", "open", "android"]);
+    await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async syncAndroid(options: { regenerate?: boolean } = {}) {
     await this.prepareWww();
-    await this.#prepareAndroid(options);
+    await this.#prepareAndroid({ operation: "release", env: "debug", ...options });
     this.app.log(`Sync Android Completed.`);
   }
   async runAndroid({ operation, env, regenerate = false }: RunConfig) {
     if (operation === "release") await this.prepareWww();
-    await this.#prepareAndroid({ regenerate });
+    await this.#prepareAndroid({ operation, env, regenerate });
     this.app.logger.info(`Running Android in ${operation} mode on ${env} env`);
     const args = ["cap", "run", "android"];
-    if (operation !== "release") args.push("--live-reload");
-    await this.#spawn("npx", args, {
-      env: this.#commandEnv(operation, env),
-      stdio: "inherit",
-    });
+    await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
 
   async releaseIos() {
     await this.prepareWww();
-    await this.#prepareIos();
+    await this.#prepareIos({ operation: "release", env: "main" });
   }
   async releaseAndroid() {
     await this.prepareWww();
-    await this.#prepareAndroid();
+    await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
     const htmlSource = path.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!(await Bun.file(htmlSource).exists()))
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
-    const wwwDir = path.join(this.targetRoot, "www");
-    await rm(wwwDir, { recursive: true, force: true });
-    await mkdir(wwwDir, { recursive: true });
-    await Bun.write(path.join(wwwDir, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await rm(this.targetWebRoot, { recursive: true, force: true });
+    await mkdir(this.targetWebRoot, { recursive: true });
+    await Bun.write(
+      path.join(this.targetWebRoot, "index.html"),
+      this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()),
+    );
   }
   #injectMobileTargetMeta(html: string) {
     const basePath = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -198,45 +212,75 @@ export class CapacitorApp {
   async #writeCapacitorConfig() {
     await mkdir(this.targetRoot, { recursive: true });
     const appInfoPath = path
-      .relative(this.targetRoot, path.join(this.app.cwdPath, "akan.app.json"))
+      .relative(this.app.cwdPath, path.join(this.app.cwdPath, "akan.app.json"))
       .split(path.sep)
       .join("/");
     const baseConfigPath = path
-      .relative(this.targetRoot, path.join(this.app.workspace.cwdPath, "pkgs/akanjs/devkit/capacitor.base.config"))
+      .relative(this.app.cwdPath, path.join(this.app.workspace.cwdPath, "pkgs/akanjs/devkit/capacitor.base.config"))
       .split(path.sep)
       .join("/");
-    const content = `import { withBase } from "${baseConfigPath.startsWith(".") ? baseConfigPath : `./${baseConfigPath}`}";
-import appInfo from "${appInfoPath}";
+    const content = `import type { AppScanResult } from "akanjs/devkit";
+import { withBase } from "${baseConfigPath.startsWith(".") ? baseConfigPath : `./${baseConfigPath}`}";
+import appInfo from "${appInfoPath.startsWith(".") ? appInfoPath : `./${appInfoPath}`}";
 
-export default withBase((config) => config, appInfo, "${this.target.name}");
+export default withBase(
+  (config, target) => ({
+    ...config,
+    webDir: \`mobile/\${target.name}/www\`,
+    android: {
+      ...config.android,
+      path: "android",
+    },
+    ios: {
+      ...config.ios,
+      path: "ios",
+    },
+  }),
+  appInfo as AppScanResult,
+);
 `;
-    await Bun.write(path.join(this.targetRoot, "capacitor.config.ts"), content);
+    await Bun.write(path.join(this.app.cwdPath, "capacitor.config.ts"), content);
   }
   async #prepareTargetAssets() {
     if (!this.target.assets) return;
-    const assetsDir = path.join(this.targetRoot, "assets");
-    await mkdir(assetsDir, { recursive: true });
+    await mkdir(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp(path.join(this.app.cwdPath, this.target.assets.icon), path.join(assetsDir, "icon.png"), { force: true });
+      await cp(path.join(this.app.cwdPath, this.target.assets.icon), path.join(this.targetAssetRoot, "icon.png"), {
+        force: true,
+      });
     if (this.target.assets.splash)
-      await cp(path.join(this.app.cwdPath, this.target.assets.splash), path.join(assetsDir, "splash.png"), {
+      await cp(path.join(this.app.cwdPath, this.target.assets.splash), path.join(this.targetAssetRoot, "splash.png"), {
         force: true,
       });
   }
   async #prepareExternalFiles(platform: "ios" | "android") {
     const files = this.target.files?.[platform];
     if (!files) return;
+    const platformRoot = path.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(
       Object.entries(files).map(async ([to, from]) => {
-        const targetPath = path.join(this.targetRoot, platform, to);
+        const targetPath = path.join(platformRoot, to);
         await mkdir(path.dirname(targetPath), { recursive: true });
         await cp(path.join(this.app.cwdPath, from), targetPath, { force: true });
       }),
     );
   }
-  async #generateAssets() {
+  async #generateAssets({ operation, env }: Pick<RunConfig, "operation" | "env">) {
     if (!this.target.assets) return;
-    await this.#spawn("npx", ["@capacitor/assets", "generate"]);
+    await this.#spawnMobile(
+      "npx",
+      [
+        "@capacitor/assets",
+        "generate",
+        "--assetPath",
+        path.posix.join(this.targetRootPath, "assets"),
+        "--iosProject",
+        this.iosProjectPath,
+        "--androidProject",
+        this.androidRootPath,
+      ],
+      { operation, env },
+    );
   }
   async #applyIosMetadata() {
     this.project.ios.setBundleId("App", "Debug", this.target.appId);
@@ -291,16 +335,26 @@ export default withBase((config) => config, appInfo, "${this.target.name}");
     }
   }
   #commandEnv(operation: "local" | "release", env: "local" | "debug" | "develop" | "main") {
-    return {
-      ...process.env,
+    return this.app.getCommandEnv({
       APP_OPERATION_MODE: operation,
-      AKAN_PUBLIC_OPERATION_MODE: operation,
+      AKAN_PUBLIC_OPERATION_MODE: env === "local" ? "local" : "cloud",
       AKAN_PUBLIC_ENV: env,
       AKAN_MOBILE_TARGET: this.target.name,
-    };
+    });
   }
   async #spawn(command: string, args: string[] = [], options: Parameters<AppExecutor["spawn"]>[2] = {}) {
-    return await this.app.spawn(command, args, { cwd: this.targetRoot, ...options });
+    return await this.app.spawn(command, args, { cwd: this.app.cwdPath, ...options });
+  }
+  async #spawnMobile(
+    command: string,
+    args: string[] = [],
+    { operation, env }: Pick<RunConfig, "operation" | "env">,
+    options: Parameters<AppExecutor["spawn"]>[2] = {},
+  ) {
+    return await this.#spawn(command, args, {
+      ...options,
+      env: { ...this.#commandEnv(operation, env), ...options.env },
+    });
   }
   async addCamera() {
     await this.#setPermissionInIos({

package/devkit/incrementalBuilder/incrementalBuilder.host.ts

@@ -17,7 +17,17 @@ interface IncrementalBuilderHostOptions {
   onMessage: (message: BuilderMessage) => void;
 }
 
+type IncrementalBuilderStatus = "starting" | "ready" | "restarting" | "stopped";
+
+interface IncrementalBuilderStartOptions {
+  onExit?: () => void;
+  onReady?: () => void;
+  onRestartReady?: () => void;
+}
+
 export class IncrementalBuilderHost {
+  static readonly #restartBaseDelayMs = 1_000;
+  static readonly #restartMaxDelayMs = 30_000;
   logger = new Logger("IncrementalBuilderHost");
   entry: string;
   env: Record<string, string>;
@@ -25,42 +35,106 @@ export class IncrementalBuilderHost {
   ready = false;
   readonly #onMessage: (message: BuilderMessage) => void;
   #proc: Bun.Subprocess<"ignore", "inherit", "inherit"> | null = null;
+  #status: IncrementalBuilderStatus = "stopped";
+  #restartAttempts = 0;
+  #restartTimer: ReturnType<typeof setTimeout> | null = null;
+  #manualStop = false;
+  #startOptions: IncrementalBuilderStartOptions = {};
   constructor({ app, entry, env, onMessage }: IncrementalBuilderHostOptions) {
     this.app = app;
     this.entry = entry;
     this.env = env;
     this.#onMessage = onMessage;
   }
-  start({ onExit, onReady }: { onExit?: () => void; onReady?: () => void }) {
+  get status() {
+    return this.#status;
+  }
+  start(options: IncrementalBuilderStartOptions = {}) {
     if (this.#proc) this.stop();
-    this.#proc = Bun.spawn(["bun", this.entry], {
+    this.#manualStop = false;
+    this.#startOptions = options;
+    this.#spawn(false);
+    return this;
+  }
+  #spawn(isRestart: boolean) {
+    this.#status = isRestart ? "restarting" : "starting";
+    this.ready = false;
+    let proc!: Bun.Subprocess<"ignore", "inherit", "inherit">;
+    proc = Bun.spawn(["bun", this.entry], {
       cwd: this.app.cwdPath,
       env: { ...this.env, AKAN_WATCH: "1" },
       stdio: ["ignore", "inherit", "inherit"],
       ipc: (msg: BuilderMessage) => {
+        if (this.#proc !== proc) return;
         if (!msg || typeof msg !== "object") return;
         if (builderMsgTypeSet.has(msg.type)) this.#onMessage(msg);
         if (msg.type === "builder-ready" && !this.ready) {
           this.ready = true;
-          onReady?.();
+          this.#status = "ready";
+          this.#restartAttempts = 0;
+          if (isRestart) this.#startOptions.onRestartReady?.();
+          else this.#startOptions.onReady?.();
         }
       },
       serialization: "advanced",
       onExit: () => {
-        onExit?.();
+        if (this.#proc !== proc) return;
+        this.#proc = null;
+        const wasReady = this.ready;
+        this.ready = false;
+        if (this.#manualStop || this.#status === "stopped") return;
+        if (!wasReady) {
+          this.#status = "stopped";
+          this.#startOptions.onExit?.();
+          return;
+        }
+        this.#scheduleRestart();
       },
     });
-    this.logger.verbose(`builder spawned pid=${this.#proc.pid} entry=${this.entry}`);
-    return this;
+    this.#proc = proc;
+    this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
+  }
+  #scheduleRestart() {
+    if (this.#manualStop || this.#restartTimer) return;
+    this.#status = "restarting";
+    const attempt = this.#restartAttempts;
+    const delay = Math.min(
+      IncrementalBuilderHost.#restartBaseDelayMs * 2 ** attempt,
+      IncrementalBuilderHost.#restartMaxDelayMs,
+    );
+    this.#restartAttempts = attempt + 1;
+    this.logger.warn(`builder exited after ready; restarting in ${delay}ms (attempt ${this.#restartAttempts})`);
+    this.#restartTimer = setTimeout(() => {
+      this.#restartTimer = null;
+      if (this.#manualStop) return;
+      this.#spawn(true);
+    }, delay);
   }
-  send(message: BuilderMessage) {
-    if (this.#proc) this.#proc.send(message);
-    else this.logger.warn("incrementalBuilderHost is not running");
+  send(message: BuilderMessage): boolean {
+    if (!this.#proc || this.#status !== "ready") {
+      this.logger.warn(`incrementalBuilderHost is ${this.#status}; cannot send ${message.type}`);
+      return false;
+    }
+    try {
+      this.#proc.send(message);
+      return true;
+    } catch (error) {
+      this.logger.warn(
+        `failed to send ${message.type} to builder: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return false;
+    }
   }
   stop() {
+    this.#manualStop = true;
+    if (this.#restartTimer) {
+      clearTimeout(this.#restartTimer);
+      this.#restartTimer = null;
+    }
     if (this.#proc) this.#proc.kill();
     this.#proc = null;
     this.ready = false;
+    this.#status = "stopped";
   }
   static async create(app: App, env: Record<string, string>, onMessage: (message: BuilderMessage) => void) {
     const candidates = [

package/devkit/mobile/mobileTarget.ts

@@ -36,9 +36,10 @@ const resolveMobileTargetByBasePath = (
   const [template] = targets;
   if (!template) return undefined;
   return {
-    name: template.name,
+    name: normalizedBasePath,
     config: {
       ...template.config,
+      name: normalizedBasePath,
       basePath: normalizedBasePath,
     },
   };

package/devkit/scanInfo.ts

@@ -59,6 +59,7 @@ const appRootAllowedDirs = new Set([
   "env",
   "ios",
   "lib",
+  "mobile",
   "page",
   "private",
   "public",

package/document/dataLoader.ts

@@ -1,11 +1,8 @@
 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 = {
@@ -13,6 +10,143 @@ type LoaderModel = {
 };
 type ArrayElementLoaderItem = LoaderItem & { key: unknown };
 type QueryRecord = Record<string, unknown>;
+type BatchLoadFn<Key, Value> = (
+  keys: readonly Key[],
+) => PromiseLike<ReadonlyArray<Value | Error>> | ReadonlyArray<Value | Error>;
+
+interface DataLoaderOptions<Key, CacheKey> {
+  cache?: boolean;
+  cacheKeyFn?: (key: Key) => CacheKey;
+  batch?: boolean;
+  batchScheduleFn?: (callback: () => void) => void;
+  maxBatchSize?: number;
+  name?: string;
+}
+
+interface BatchItem<Key, Value> {
+  key: Key;
+  resolve: (value: Value) => void;
+  reject: (reason: unknown) => void;
+}
+
+/** Minimal DataLoader-compatible batch loader used by Akan document resolvers. */
+export class DataLoader<Key, Value, CacheKey = Key> {
+  readonly name?: string;
+  readonly #batchLoadFn: BatchLoadFn<Key, Value>;
+  readonly #cache: boolean;
+  readonly #cacheKeyFn: (key: Key) => CacheKey;
+  readonly #batch: boolean;
+  readonly #batchScheduleFn: (callback: () => void) => void;
+  readonly #maxBatchSize: number;
+  readonly #promiseCache = new Map<CacheKey, Promise<Value>>();
+  #queue: BatchItem<Key, Value>[] = [];
+  #scheduled = false;
+
+  constructor(batchLoadFn: BatchLoadFn<Key, Value>, options: DataLoaderOptions<Key, CacheKey> = {}) {
+    this.#batchLoadFn = batchLoadFn;
+    this.#cache = options.cache !== false;
+    this.#cacheKeyFn = options.cacheKeyFn ?? ((key) => key as unknown as CacheKey);
+    this.#batch = options.batch !== false;
+    this.#batchScheduleFn = options.batchScheduleFn ?? ((callback) => queueMicrotask(callback));
+    this.#maxBatchSize = options.maxBatchSize ?? Number.POSITIVE_INFINITY;
+    this.name = options.name;
+  }
+
+  load(key: Key): Promise<Value> {
+    const cacheKey = this.#cacheKeyFn(key);
+    if (this.#cache) {
+      const cached = this.#promiseCache.get(cacheKey);
+      if (cached) return cached;
+    }
+
+    const promise = new Promise<Value>((resolve, reject) => {
+      this.#queue.push({ key, resolve, reject });
+      if (this.#batch) this.#schedule();
+      else this.#dispatch();
+    });
+    if (this.#cache) this.#promiseCache.set(cacheKey, promise);
+    return promise;
+  }
+
+  async loadMany(keys: readonly Key[]): Promise<Array<Value | Error>> {
+    const results = await Promise.allSettled(keys.map((key) => this.load(key)));
+    return results.map((result) => (result.status === "fulfilled" ? result.value : toError(result.reason)));
+  }
+
+  clear(key: Key): this {
+    this.#promiseCache.delete(this.#cacheKeyFn(key));
+    return this;
+  }
+
+  clearAll(): this {
+    this.#promiseCache.clear();
+    return this;
+  }
+
+  prime(key: Key, value: Value | Error): this {
+    if (!this.#cache) return this;
+    const cacheKey = this.#cacheKeyFn(key);
+    if (this.#promiseCache.has(cacheKey)) return this;
+    this.#promiseCache.set(cacheKey, value instanceof Error ? Promise.reject(value) : Promise.resolve(value));
+    return this;
+  }
+
+  #schedule() {
+    if (this.#scheduled) return;
+    this.#scheduled = true;
+    this.#batchScheduleFn(() => this.#dispatch());
+  }
+
+  #dispatch() {
+    this.#scheduled = false;
+    const batch = this.#queue.splice(0, this.#maxBatchSize);
+    if (this.#queue.length > 0) this.#schedule();
+    if (batch.length === 0) return;
+    const keys = batch.map(({ key }) => key);
+    Promise.resolve(this.#batchLoadFn(keys)).then(
+      (values) => {
+        if (values.length !== batch.length) {
+          const error = new Error(`DataLoader expected ${batch.length} values, received ${values.length}`);
+          batch.forEach(({ reject }) => {
+            reject(error);
+          });
+          return;
+        }
+        values.forEach((value, index) => {
+          if (value instanceof Error) batch[index]?.reject(value);
+          else batch[index]?.resolve(value as Value);
+        });
+      },
+      (error) => {
+        batch.forEach(({ reject }) => {
+          reject(error);
+        });
+      },
+    );
+  }
+}
+
+function toError(reason: unknown): Error {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+
+function keyBy<T>(items: T[], keyOrGetter: keyof T | ((item: T) => unknown)): Record<string, T> {
+  const entries = items.map((item) => {
+    const key = typeof keyOrGetter === "function" ? keyOrGetter(item) : item[keyOrGetter];
+    return [String(key), item] as const;
+  });
+  return Object.fromEntries(entries);
+}
+
+function groupBy<T>(items: T[], getKey: (item: T) => unknown): Record<string, T[]> {
+  const groups: Record<string, T[]> = {};
+  for (const item of items) {
+    const key = String(getKey(item));
+    groups[key] ??= [];
+    groups[key].push(item);
+  }
+  return groups;
+}
 
 const setQueryOperator = (query: QueryOf<unknown>, fieldName: string, op: "oneOf" | "has", value: unknown) => {
   (query as QueryRecord)[fieldName] = { kind: "op", op, value };
@@ -25,7 +159,7 @@ export const createLoader = <Key, Value>(model: LoaderModel, fieldName = "id", d
       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 fields.map((id: unknown) => listByKey[String(id)] ?? null);
       });
       return data as unknown as Promise<Value[]>;
     },
@@ -60,7 +194,7 @@ export const createArrayElementLoader = <K, V>(
           }));
         });
         const listByKey = groupBy(flat, (dat) => dat.key);
-        return fields.map((id) => get(listByKey, String(id), null));
+        return fields.map((id) => listByKey[String(id)] ?? null);
       });
       return data as unknown as Promise<V[]>;
     },
@@ -80,7 +214,7 @@ export const createQueryLoader = <Key, Value>(
         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 queries.map((query: QueryOf<unknown>) => listByKey[getQueryKey(query)] ?? null);
       });
       return data as unknown as Promise<Value[]>;
     },