akanjs 2.0.5 → 2.0.6

package/cli/templates/lib/sig.ts

@@ -50,8 +50,8 @@ ${[...scanInfo.service.entries()]
   )
   .join("\n")}
 
-${databaseModules.map((module) => `export const ${module} = SignalRegistry.registerDatabase(${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Slice, ${capitalize(module)});`).join("\n")}
-${serviceModules.map((module) => `export const ${module} = SignalRegistry.registerService(${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Endpoint, ${capitalize(module)});`).join("\n")}
+${databaseModules.map((module) => `export const ${module} = SignalRegistry.registerDatabase("${module}" as const, ${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Slice, ${capitalize(module)});`).join("\n")}
+${serviceModules.map((module) => `export const ${module} = SignalRegistry.registerService("${module}" as const, ${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Endpoint, ${capitalize(module)});`).join("\n")}
 
 export const fetch = FetchClient.from(${[...(libs.length === 0 ? ["base"] : libs), ...databaseModules, ...serviceModules].join(", ")});
 

package/cli/workspace/workspace.runner.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { FileSys, type Exec, type PackageJson, runner, type Workspace, WorkspaceExecutor } from "akanjs/devkit";
-import latestVersion from "latest-version";
+import { type Exec, FileSys, type PackageJson, runner, type Workspace, WorkspaceExecutor } from "akanjs/devkit";
+import { getLatestPackageVersion } from "../npmRegistry";
 
 export class WorkspaceRunner extends runner("workspace") {
   async createWorkspace(
@@ -13,7 +13,7 @@ export class WorkspaceRunner extends runner("workspace") {
 
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname}/${repoName}...`);
-    const latestTypesBunVersion = await latestVersion("@types/bun");
+    const latestTypesBunVersion = await getLatestPackageVersion("@types/bun");
     await workspace.applyTemplate({
       basePath: ".",
       template: "workspaceRoot",

package/client/cookie.ts

@@ -1,12 +1,16 @@
 import { getEnv } from "akanjs/base";
-import { Logger } from "akanjs/common";
+import { decodeJwtPayload, Logger } from "akanjs/common";
 import type { Account } from "akanjs/fetch";
 import { requestStorage } from "akanjs/fetch";
-import Cookies from "js-cookie";
-import { jwtDecode } from "jwt-decode";
 import { storage } from "./storage";
 import { fetch } from "./useClient";
 
+interface CookieOptions {
+  path?: string;
+  sameSite?: "strict" | "lax" | "none";
+  secure?: boolean;
+}
+
 function parseCookieHeader(cookieHeader: string): Map<string, { name: string; value: string }> {
   const entries = cookieHeader
     .split(";")
@@ -30,22 +34,13 @@ export const cookies = (): Map<string, { name: string; value: string }> => {
     if (!req) return new Map();
     return parseCookieHeader(req.headers.get("cookie") ?? "");
   }
-  const cookie = Cookies.get();
-  return new Map(
-    Object.entries(cookie).map(([key, value]) => [
-      key,
-      {
-        name: key,
-        value: typeof value === "string" && value.startsWith("j:") ? (JSON.parse(value.slice(2)) as string) : value,
-      },
-    ]),
-  );
+  return parseCookieHeader(document.cookie);
 };
 
 export const setCookie = (
   key: string,
   value: string,
-  options: Cookies.CookieAttributes = { path: "/", sameSite: "none", secure: true },
+  options: CookieOptions = { path: "/", sameSite: "none", secure: true },
 ) => {
   if (getEnv().side === "server") return;
   else
@@ -88,7 +83,7 @@ export const getAccount = <AddData = unknown>(): Account<AddData> => {
   const jwt = getCookie("jwt") ?? getHeader("jwt");
   const defaultAccount = { appName: getEnv().appName, environment: getEnv().environment } as Account<AddData>;
   if (!jwt) return defaultAccount;
-  const account: Account<AddData> = jwtDecode<Account<AddData>>(jwt);
+  const account = decodeJwtPayload<Account<AddData>>(jwt);
   if (account.appName !== getEnv().appName || account.environment !== getEnv().environment) return defaultAccount;
   return account;
 };

package/common/index.ts

@@ -11,6 +11,7 @@ export { isEmail } from "./isEmail";
 export { isPhoneNumber } from "./isPhoneNumber";
 export { isQueryEqual } from "./isQueryEqual";
 export { isValidDate } from "./isValidDate";
+export { decodeJwtPayload } from "./jwtDecode";
 export { Logger, type LoggerSink, type LoggerSinkEntry, type LogLevel } from "./Logger";
 export {
   type AkanI18nConfig,

package/common/jwtDecode.ts

@@ -0,0 +1,17 @@
+function decodeBase64Url(input: string): string {
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  if (typeof atob === "function") return atob(padded);
+  return Buffer.from(padded, "base64").toString("binary");
+}
+
+/** Decodes a JWT payload without validating its signature. */
+export function decodeJwtPayload<T = unknown>(jwt: string): T {
+  const [, payload] = jwt.split(".");
+  if (!payload) throw new Error("Invalid JWT payload");
+  const binary = decodeBase64Url(payload);
+  const json = decodeURIComponent(
+    [...binary].map((char) => `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`).join(""),
+  );
+  return JSON.parse(json) as T;
+}

package/devkit/akanApp/akanApp.host.ts

@@ -9,6 +9,8 @@ import { IncrementalBuilderHost } from "../incrementalBuilder";
 const backendMsgTypeSet = new Set<BuilderMessage["type"]>(["build-route"]);
 const BACKEND_RESTART_DEBOUNCE_MS = 120;
 const BACKEND_GRACEFUL_TIMEOUT_MS = 3000;
+const BACKEND_RECOVERY_BASE_DELAY_MS = 1_000;
+const BACKEND_RECOVERY_MAX_DELAY_MS = 30_000;
 const BUILDER_READY_TIMEOUT_MS = 15000;
 const BUILDER_START_MAX_ATTEMPTS = 3;
 const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
@@ -132,6 +134,8 @@ export class AkanAppHost {
   #backendReady = false;
   #plannedBackendStops = new WeakSet<Bun.Subprocess<"ignore", "inherit", "inherit">>();
   #restartTimer: ReturnType<typeof setTimeout> | null = null;
+  #backendRecoveryTimer: ReturnType<typeof setTimeout> | null = null;
+  #backendRecoveryAttempts = 0;
   #restartFiles = new Set<string>();
   #latestPagesUpdated: Extract<BuilderMessage, { type: "pages-updated" }> | null = null;
   #latestCssUpdated: Extract<BuilderMessage, { type: "css-updated" }> | null = null;
@@ -162,6 +166,10 @@ export class AkanAppHost {
       clearTimeout(this.#restartTimer);
       this.#restartTimer = null;
     }
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
     await this.#stopBackend();
     this.#stopBuilder();
     return this;
@@ -185,6 +193,7 @@ export class AkanAppHost {
         if (!msg || typeof msg !== "object") return;
         if (msg.type === "backend-ready") {
           this.#backendReady = true;
+          this.#backendRecoveryAttempts = 0;
           this.logger.verbose(`backend ready pid=${msg.pid}`);
           this.#replayBuilderState();
           return;
@@ -199,7 +208,7 @@ export class AkanAppHost {
           this.#plannedBackendStops.delete(backend);
           return;
         }
-        this.#stopBuilder();
+        this.#scheduleBackendRecovery("backend-exit");
       },
     });
     this.#backend = backend;
@@ -245,6 +254,10 @@ export class AkanAppHost {
   }
   #scheduleBackendRestart(files: string[]) {
     for (const file of files) this.#restartFiles.add(file);
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
     if (this.#restartTimer) clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
       this.#restartTimer = null;
@@ -255,9 +268,26 @@ export class AkanAppHost {
   }
   async #restartBackend(files: string[]) {
     this.logger.verbose(`[backend-reload] restarting backend for ${files.length} file(s)`);
+    this.#backendRecoveryAttempts = 0;
     await Promise.all([this.#stopBackend(), this.#backendGraph.refresh()]);
     this.#startBackend();
   }
+  #scheduleBackendRecovery(reason: string) {
+    if (this.#backendRecoveryTimer || this.#backend) return;
+    const attempt = this.#backendRecoveryAttempts;
+    const delay = Math.min(BACKEND_RECOVERY_BASE_DELAY_MS * 2 ** attempt, BACKEND_RECOVERY_MAX_DELAY_MS);
+    this.#backendRecoveryAttempts = attempt + 1;
+    this.logger.warn(
+      `[backend-recovery] backend exited unexpectedly (${reason}); restarting in ${delay}ms (attempt ${this.#backendRecoveryAttempts})`,
+    );
+    this.#backendRecoveryTimer = setTimeout(() => {
+      this.#backendRecoveryTimer = null;
+      if (this.#backend) return;
+      void this.#backendGraph.refresh().finally(() => {
+        if (!this.#backend) this.#startBackend();
+      });
+    }, delay);
+  }
   #enqueueBuilderMessage(message: BuilderMessage) {
     this.#builderMessageQueue = this.#builderMessageQueue
       .then(() => this.#handleBuilderMessage(message))
@@ -319,7 +349,6 @@ export class AkanAppHost {
     return new Promise<void>((resolve, reject) => {
       if (!this.#builder) throw new Error("Builder Not Found");
       let settled = false;
-      let ready = false;
       const settle = (fn: () => void) => {
         if (settled) return;
         settled = true;
@@ -331,22 +360,30 @@ export class AkanAppHost {
       }, BUILDER_READY_TIMEOUT_MS);
       this.#builder.start({
         onExit: () => {
-          if (settled && ready) {
-            void this.#stopBackend();
-            return;
-          }
           settle(() => reject(new Error(`[cli] builder exited before emitting builder-ready (attempt ${attempt})`)));
         },
         onReady: () => {
-          ready = true;
           settle(resolve);
         },
+        onRestartReady: () => {
+          this.logger.verbose("[builder-recovery] builder ready after restart; replaying latest state");
+          this.#replayBuilderState();
+        },
       });
     });
   }
   #sendToBuilder(message: BuilderMessage) {
-    if (this.#builder) this.#builder.send(message);
-    else this.logger.warn("akanAppHost is not running");
+    if (this.#builder?.send(message)) return;
+    if (message.type === "build-route") {
+      this.#sendToBackend({
+        type: "build-route-res",
+        id: message.id,
+        ok: false,
+        error: `builder is ${this.#builder?.status ?? "stopped"}; reload after the builder is ready`,
+      });
+      return;
+    }
+    this.logger.warn("akanAppHost builder is not running");
   }
   #stopBuilder() {
     if (!this.#builder) return;

package/devkit/akanConfig/akanConfig.ts

@@ -269,7 +269,8 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
     const rootVersion = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
     if (rootVersion) return rootVersion;
     const akanPackageJson = getAkanPackageJson();
-    if (AKAN_RUNTIME_PACKAGES.has(lib)) return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
+    if (AKAN_RUNTIME_PACKAGES.has(lib))
+      return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
   }
   getProductionPackageJson(data: Partial<PackageJson> = {}): PackageJson {
     return {

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/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[]>;
     },

package/document/database.ts

@@ -2,7 +2,7 @@ import type { Dayjs, MergedValues, PromiseOrObject } from "akanjs/base";
 import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor } from "akanjs/service";
-import type DataLoader from "dataloader";
+import type { DataLoader } from "./dataLoader";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
 import type { CRUDEventType, Mdl, SaveEventType } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "sourceType": "module",
   "type": "module",
   "bin": {
@@ -162,7 +162,6 @@
     }
   },
   "dependencies": {
-    "@formatjs/intl-localematcher": "^0.8.8",
     "@inquirer/prompts": "^8.4.3",
     "@langchain/core": "^1.1.47",
     "@langchain/deepseek": "^1.0.26",
@@ -171,29 +170,19 @@
     "chalk": "^5.6.2",
     "clsx": "^2.1.1",
     "commander": "^14.0.3",
-    "compare-versions": "^6.1.1",
-    "dataloader": "^2.2.3",
     "dayjs": "^1.11.20",
     "fontaine": "^0.8.0",
     "fonteditor-core": "^2.6.3",
     "ignore": "^7.0.5",
     "immer": "^11.1.8",
     "ink": "^6.8.0",
-    "js-cookie": "^3.0.7",
     "js-yaml": "^4.1.1",
-    "jwt-decode": "^4.0.0",
-    "latest-version": "^9.0.0",
-    "lodash": "^4.18.1",
-    "negotiator": "^1.0.0",
-    "open": "^11.0.0",
     "ora": "^9.4.0",
-    "pluralize": "^8.0.0",
     "qrcode": "^1.5.4",
     "sharp": "^0.34.5",
     "ssh2": "^1.17.0",
     "subset-font": "^2.5.0",
-    "tailwindcss": "^4.3.0",
-    "uuid": "^13.0.2"
+    "tailwindcss": "^4.3.0"
   },
   "peerDependencies": {
     "@capacitor-community/contacts": "^7.2.0",
@@ -222,6 +211,8 @@
     "croner": "^10.0.1",
     "daisyui": "^5.5.20",
     "file-saver": "^2.0.5",
+    "fontaine": "^0.8.0",
+    "fonteditor-core": "^2.6.3",
     "ioredis": "^5.10.1",
     "mermaid": "^11.15.0",
     "postgres": "^3.4.9",
@@ -237,7 +228,10 @@
     "react-simple-pull-to-refresh": "^1.3.4",
     "react-spring": "^9.7.5",
     "scheduler": "^0.27.0",
+    "sharp": "^0.34.5",
+    "subset-font": "^2.5.0",
     "tailwind-scrollbar": "^4.0.2",
+    "tailwindcss": "^4.3.0",
     "typescript": "^6.0.3"
   },
   "peerDependenciesMeta": {