akanjs 2.0.6 → 2.0.7

package/server/resolver/database.resolver.ts

@@ -27,6 +27,22 @@ import {
   DatabaseAdaptorRole,
   type DocumentStore,
 } from "akanjs/service";
+import { getCurrentTrace, traceDataLoaderBatch } from "akanjs/signal";
+
+/**
+ * Times a store query and records it against the active request trace (no-op when
+ * tracing is disabled). Used to surface "queries per request" and DB latency share.
+ */
+const timedQuery = async <T>(fn: () => Promise<T>): Promise<T> => {
+  const trace = getCurrentTrace();
+  if (!trace) return await fn();
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    trace.countDbQuery(performance.now() - start);
+  }
+};
 
 export class DatabaseResolver {
   static resolveDatabase(constant: ConstantModel, database: DatabaseModel): AdaptorCls<DatabaseInstance> {
@@ -55,6 +71,18 @@ export class DatabaseResolver {
     const schema = new DocumentSchema();
     database.model._onSchema(schema as any);
     database.model._libsOnSchema(schema as any);
+    const filterMeta = getFilterMeta(database.filter);
+    const indexedSortFieldKeys = new Set<string>();
+    for (const sort of Object.values(filterMeta.sort)) {
+      if (!sort || typeof sort !== "object") continue;
+      const sortFields = Object.entries(sort as Record<string, 1 | -1>);
+      if (!sortFields.length) continue;
+      const fields = Object.fromEntries([["removedAt", 1] as const, ...sortFields]);
+      const key = Object.keys(fields).join(",");
+      if (indexedSortFieldKeys.has(key)) continue;
+      indexedSortFieldKeys.add(key);
+      schema.index(fields);
+    }
 
     class DatabaseModelInstance extends adapt(`${modelName}Model`, ({ plug }) => ({
       __database: plug(DatabaseAdaptorRole, (database) => database),
@@ -71,7 +99,12 @@ export class DatabaseResolver {
         await this.__store.ensure();
         this.__model = this.#createModelFacade() as unknown as Mdl<any, any>;
         this.__loader = new DataLoader<string, any>(
-          async (ids) => await Promise.all(ids.map((id) => this.__store.findOne({ id }))),
+          async (ids) => {
+            traceDataLoaderBatch(ids.length);
+            const docs = await timedQuery(() => this.__store.find({ id: documentQueryHelper.oneOf([...ids]) }));
+            const byId = new Map(docs.map((doc) => [String(doc.id), doc]));
+            return ids.map((id) => byId.get(String(id)) ?? null);
+          },
           { name: `${modelName}Loader`, cache: false },
         );
         Object.assign(this, {
@@ -81,18 +114,35 @@ export class DatabaseResolver {
         Object.entries(getLoaderInfos(database.model)).forEach(([key, loaderInfo]) => {
           Object.assign(this, {
             [key]: new DataLoader<any, any>(async (keys) => {
-              return await Promise.all(
-                keys.map(async (key) => {
-                  const query =
-                    loaderInfo.type === "query"
-                      ? key
-                      : {
-                          [loaderInfo.field as string]:
-                            loaderInfo.type === "arrayField" ? documentQueryHelper.has(key) : key,
-                        };
-                  return await this.__store.findOne(documentQueryHelper.all(loaderInfo.defaultQuery, query));
-                }),
+              traceDataLoaderBatch(keys.length);
+              if (loaderInfo.type === "query") {
+                const fields = loaderInfo.field as string[];
+                const query = { kind: "any", queries: keys } as QueryOf<unknown>;
+                const docs = await timedQuery(() =>
+                  this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
+                );
+                const byKey = new Map(docs.map((doc) => [fields.map((field) => String(doc[field])).join(""), doc]));
+                return keys.map(
+                  (queryKey) => byKey.get(fields.map((field) => String(queryKey[field])).join("")) ?? null,
+                );
+              }
+              const field = loaderInfo.field as string;
+              const query = {
+                [field]: documentQueryHelper.oneOf([...keys]),
+              };
+              const docs = await timedQuery(() =>
+                this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
               );
+              if (loaderInfo.type === "arrayField") {
+                const byKey = new Map<string, unknown>();
+                for (const doc of docs) {
+                  const values = Array.isArray(doc[field]) ? doc[field] : [];
+                  for (const value of values) if (!byKey.has(String(value))) byKey.set(String(value), doc);
+                }
+                return keys.map((key) => byKey.get(String(key)) ?? null);
+              }
+              const byKey = new Map(docs.map((doc) => [String(doc[field]), doc]));
+              return keys.map((key) => byKey.get(String(key)) ?? null);
             }),
           });
         });
@@ -105,7 +155,7 @@ export class DatabaseResolver {
         }
         const createFindManyChain = (
           query: QueryOf<any>,
-          options: { sort?: any; skip?: number; limit?: number } = {},
+          options: { sort?: any; skip?: number; limit?: number; select?: any } = {},
         ) => {
           const chain: any = {
             sort(sort: any) {
@@ -117,8 +167,8 @@ export class DatabaseResolver {
             limit(limit: number) {
               return createFindManyChain(query, { ...options, limit });
             },
-            select() {
-              return createFindManyChain(query, options);
+            select(select?: any) {
+              return createFindManyChain(query, { ...options, select });
             },
             
             then(resolve: (value: any[]) => void, reject: (reason: unknown) => void) {
@@ -130,7 +180,7 @@ export class DatabaseResolver {
           };
           return chain;
         };
-        const createFindOneChain = (query: QueryOf<any>, options: { sort?: any; skip?: number } = {}) => {
+        const createFindOneChain = (query: QueryOf<any>, options: { sort?: any; skip?: number; select?: any } = {}) => {
           const chain: any = {
             sort(sort: any) {
               return createFindOneChain(query, { ...options, sort });
@@ -138,8 +188,8 @@ export class DatabaseResolver {
             skip(skip: number) {
               return createFindOneChain(query, { ...options, skip });
             },
-            select() {
-              return createFindOneChain(query, options);
+            select(select?: any) {
+              return createFindOneChain(query, { ...options, select });
             },
             
             then(resolve: (value: any | null) => void, reject: (reason: unknown) => void) {
@@ -153,10 +203,13 @@ export class DatabaseResolver {
         };
         return Object.assign(Model, {
           refName: modelName,
-          pickOne: (query: QueryOf<any>, _projection?: any) => store.pickOne(query),
-          pickById: (id: string | undefined, _projection?: any) => {
+          pickOne: (query: QueryOf<any>, projection?: any) => store.pickOne(query, { select: projection }),
+          pickById: (id: string | undefined, projection?: any) => {
             if (!id) throw new Error("No Document ID");
-            return store.pickById(id);
+            return store.findOne({ id }, { select: projection }).then((doc) => {
+              if (!doc) throw new Error(`No Document (${modelName}): ${id}`);
+              return doc;
+            });
           },
           exists: async (query: QueryOf<any>) => await store.exists(query),
           sample: (query: QueryOf<any>, size = 1) => store.find(query, { sample: size, limit: size }),
@@ -184,20 +237,20 @@ export class DatabaseResolver {
       }
 
       async __list(query?: QueryOf<any>, queryOption?: ListQueryOption): Promise<any[]> {
-        const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
-        return await this.__store.find(find, { sort, skip, limit, sample });
+        const { find, sort, skip, limit, sample, select } = getListQuery(query, queryOption);
+        return await timedQuery(() => this.__store.find(find, { sort, skip, limit, sample, select }));
       }
       async __listIds(query?: QueryOf<any>, queryOption?: ListQueryOption): Promise<string[]> {
         const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
-        return await this.__store.findIds(find, { sort, skip, limit, sample });
+        return await timedQuery(() => this.__store.findIds(find, { sort, skip, limit, sample }));
       }
       async __find(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<any | null> {
         const { find, sort, skip, sample } = getFindQuery(query, queryOption);
-        return await this.__store.findOne(find, { sort, skip, sample });
+        return await timedQuery(() => this.__store.findOne(find, { sort, skip, sample }));
       }
       async __findId(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<string | null> {
         const { find, sort, skip, sample } = getFindQuery(query, queryOption);
-        return await this.__store.findId(find, { sort, skip, sample });
+        return await timedQuery(() => this.__store.findId(find, { sort, skip, sample }));
       }
       async __pick(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<any> {
         const { find, sort, skip, sample } = getFindQuery(query, queryOption);
@@ -213,7 +266,7 @@ export class DatabaseResolver {
         return await this.__store.exists(query);
       }
       async __count(query?: QueryOf<any>): Promise<number> {
-        return await this.__store.count(query);
+        return await timedQuery(() => this.__store.count(query));
       }
       async __insight(query?: QueryOf<any>): Promise<any> {
         return await this.__store.insight(query);
@@ -254,13 +307,13 @@ export class DatabaseResolver {
         return await this.__store.clone(data);
       }
       async __create(data: DataInputOf<any, any>) {
-        return await this.__store.create(data);
+        return await timedQuery(() => this.__store.create(data));
       }
       async [`create${className}`](data: DataInputOf<any, any>) {
         return this.__create(data);
       }
       async __update(id: string, data: DataInputOf<any, any>) {
-        return await this.__store.update(id, data);
+        return await timedQuery(() => this.__store.update(id, data));
       }
       async [`update${className}`](id: string, data: DataInputOf<any, any>) {
         return this.__update(id, data);
@@ -289,8 +342,6 @@ export class DatabaseResolver {
       const queryOption = hasQueryOption ? lastArg : {};
       return { query, queryOption };
     };
-    const filterMeta = getFilterMeta(database.filter);
-
     Object.entries(filterMeta.query).forEach(([queryKey, filterInfo]) => {
       const queryFn = filterInfo.queryFn;
       if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);

package/server/resolver/signal.resolver.ts

@@ -1,4 +1,15 @@
-import { type BaseEnv, type Cls, ENDPOINT_META, getEnv, ID, INTERNAL_META, Int, SLICE_META } from "akanjs/base";
+import {
+  type BaseEnv,
+  type Cls,
+  ENDPOINT_META,
+  FIELD_META,
+  getEnv,
+  ID,
+  INTERNAL_META,
+  Int,
+  PrimitiveRegistry,
+  SLICE_META,
+} from "akanjs/base";
 import { capitalize, Logger } from "akanjs/common";
 import { serialize } from "akanjs/constant";
 import { documentQueryHelper } from "akanjs/document";
@@ -169,7 +180,12 @@ export class SignalResolver {
             const sort = requestArgs[argLength + 2] ?? "latest";
             const internalArgs = requestArgs.slice(argLength + 3);
             const query = await sliceInfo.execFn?.apply(this, [...args, ...internalArgs, documentQueryHelper]);
-            return (await this[serviceName].__list(query, { skip, limit, sort })) as any;
+            return (await this[serviceName].__list(query, {
+              skip,
+              limit,
+              sort,
+              select: SignalResolver.#selectForConstant(sliceInfo.light),
+            })) as any;
           });
 
         const insightKey = `${refName}Insight${capitalizedKey}`;
@@ -249,37 +265,37 @@ export class SignalResolver {
       if (endpointInfo.signalOption.globalPrefix !== undefined) {
         routeOptions[path] = { globalPrefix: endpointInfo.signalOption.globalPrefix };
       }
+      const normalHttpHandler = async (req: Bun.BunRequest) =>
+        await SignalContext.try(endpoint, endpointInfo, key, async () => {
+          const context = await new SignalContext(key, req, {
+            endpointInfo,
+            adaptor: endpoint,
+            registry,
+            env,
+            live,
+            middleware,
+          }).init();
+          return await context.exec();
+        });
       switch (endpointInfo.type) {
         case "query":
-          routes[path] = {
-            GET: async (req) =>
-              await SignalContext.try(endpoint, endpointInfo, key, async () => {
-                const context = await new SignalContext(key, req, {
-                  endpointInfo,
-                  adaptor: endpoint,
-                  registry,
-                  env,
-                  live,
-                  middleware,
-                }).init();
-                return await context.exec();
-              }),
-          };
+          routes[path] = SignalResolver.#canUsePrimitiveQueryFastPath(endpointInfo, middleware)
+            ? {
+                GET: async (req) => {
+                  if (SignalResolver.#hasAuthCredential(req)) return await normalHttpHandler(req);
+                  return await SignalContext.try(endpoint, endpointInfo, key, async () => {
+                    const result = await endpointInfo.execFn?.call(endpoint);
+                    return result instanceof Response ? result : Response.json(result);
+                  });
+                },
+              }
+            : {
+                GET: normalHttpHandler,
+              };
           break;
         case "mutation":
           routes[path] = {
-            POST: async (req) =>
-              await SignalContext.try(endpoint, endpointInfo, key, async () => {
-                const context = await new SignalContext(key, req, {
-                  endpointInfo,
-                  adaptor: endpoint,
-                  registry,
-                  env,
-                  live,
-                  middleware,
-                }).init();
-                return await context.exec();
-              }),
+            POST: normalHttpHandler,
           };
           break;
         case "pubsub":
@@ -349,6 +365,29 @@ export class SignalResolver {
     return trimmed ? `/${trimmed}` : "";
   }
 
+  static #selectForConstant(constant: Cls): Record<string, true> | undefined {
+    const fields = (constant as { [FIELD_META]?: Record<string, unknown> })[FIELD_META];
+    if (!fields) return undefined;
+    return Object.fromEntries(Object.keys(fields).map((field) => [field, true]));
+  }
+
+  static #canUsePrimitiveQueryFastPath(endpointInfo: EndpointInfo, middleware: Map<string, MiddlewareCls>) {
+    return (
+      process.env.AKAN_TRACE !== "1" &&
+      endpointInfo.args.length === 0 &&
+      endpointInfo.internalArgs.length === 0 &&
+      (endpointInfo.signalOption.guards?.length ?? 0) === 0 &&
+      (endpointInfo.signalOption.middlewares?.length ?? 0) === 0 &&
+      [...middleware.values()].every((MiddlewareCls) => MiddlewareCls.refName === "AccountMiddleware") &&
+      endpointInfo.returns.arrDepth === 0 &&
+      PrimitiveRegistry.has(endpointInfo.returns.returnRef as Cls)
+    );
+  }
+
+  static #hasAuthCredential(req: Request) {
+    return Boolean(req.headers.get("authorization") || req.headers.get("cookie")?.includes("jwt="));
+  }
+
   static async handleWsOpen(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry) {
     await SignalResolver.#getWebsocket(registry).registerSocket(ws);
   }

package/service/ipcTypes.ts

@@ -94,6 +94,11 @@ export interface AkanMetricsReport {
   httpHtmlCacheHits?: number;
   httpHtmlCacheMisses?: number;
   httpHtmlCacheBypass?: number;
+  eventLoopLagMeanMs?: number;
+  eventLoopLagP99Ms?: number;
+  eventLoopLagMaxMs?: number;
+  gcDurationMs?: number;
+  trace?: unknown;
 }
 
 export type AkanIpcMessage =

package/service/predefinedAdaptor/database.adaptor.ts

@@ -74,23 +74,17 @@ export interface DocumentStore {
   bulkWrite(
     operations: { updateOne: { filter: DocumentQuery; update: DocumentUpdate; upsert?: boolean } }[],
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number; upsertedId: string | null }>;
-  find(
-    query?: DocumentQuery,
-    options?: { sort?: SortOption; skip?: number | null; limit?: number | null; sample?: number },
-  ): Promise<any[]>;
+  find(query?: DocumentQuery, options?: FindManyOptions): Promise<any[]>;
   findIds(
     query?: DocumentQuery,
     options?: { sort?: SortOption; skip?: number | null; limit?: number | null; sample?: number },
   ): Promise<string[]>;
-  findOne(
-    query?: DocumentQuery,
-    options?: { sort?: SortOption; skip?: number | null; sample?: boolean },
-  ): Promise<any | null>;
+  findOne(query?: DocumentQuery, options?: FindOneOptions): Promise<any | null>;
   findId(
     query?: DocumentQuery,
     options?: { sort?: SortOption; skip?: number | null; sample?: boolean },
   ): Promise<string | null>;
-  pickOne(query?: DocumentQuery, options?: { sort?: SortOption; skip?: number | null; sample?: boolean }): Promise<any>;
+  pickOne(query?: DocumentQuery, options?: FindOneOptions): Promise<any>;
   pickById(id: string): Promise<any>;
   exists(query?: DocumentQuery): Promise<string | null>;
   count(query?: DocumentQuery): Promise<number>;
@@ -137,6 +131,15 @@ type DocumentRecord = Record<string, unknown>;
 type MutableDocumentRecord = Record<string, unknown>;
 type FieldMap = Record<string, { getProps: () => Record<string, unknown>; [key: string]: unknown }>;
 type SortOption = Record<string, 1 | -1> | null | undefined;
+type ProjectionOption = Partial<Record<string, boolean>> | null | undefined;
+type FindManyOptions = {
+  sort?: SortOption;
+  skip?: number | null;
+  limit?: number | null;
+  sample?: number;
+  select?: ProjectionOption;
+};
+type FindOneOptions = { sort?: SortOption; skip?: number | null; sample?: boolean; select?: ProjectionOption };
 type QueryOperatorName = Exclude<
   DocumentQueryNode,
   { kind: "all" } | { kind: "any" } | { kind: "not" } | { kind: "raw" }
@@ -148,6 +151,7 @@ interface SqliteDocumentRow {
   removedAt?: number | string | null;
   _doc: string;
 }
+type ProjectedSqliteDocumentRow = Omit<SqliteDocumentRow, "_doc"> & Record<string, unknown>;
 
 interface DocumentDatabaseOwner {
   getConnection(): AkanSqlClient;
@@ -510,6 +514,7 @@ export class SqliteDocumentStore {
   readonly table: string;
   readonly compiler: QueryCompiler;
   #insertStmt: AkanSqlStatement | null = null;
+  #readStmtCache = new Map<string, AkanSqlStatement>();
 
   constructor(
     private readonly owner: DocumentDatabaseOwner,
@@ -637,20 +642,23 @@ export class SqliteDocumentStore {
     return { acknowledged: true, matchedCount, modifiedCount, upsertedId };
   }
 
-  async find(
-    query?: DocumentQuery,
-    options: { sort?: SortOption; skip?: number | null; limit?: number | null; sample?: number } = {},
-  ) {
+  async find(query?: DocumentQuery, options: FindManyOptions = {}) {
     const { where, params } = this.safeQuery(query);
     const limitValue = Number(options.limit ?? 0);
     const skipValue = Number(options.skip ?? 0);
     const limit = limitValue ? ` LIMIT ${limitValue}` : "";
     const offset = skipValue ? ` OFFSET ${skipValue}` : "";
     const order = options.sample ? "ORDER BY random()" : `ORDER BY ${this.compiler.orderBy(options.sort ?? undefined)}`;
-    const rows = await this.owner
-      .getConnection()
-      .prepare(`SELECT * FROM ${quoteIdent(this.table)} WHERE ${where} ${order}${limit}${offset}`)
-      .all<SqliteDocumentRow>(...params);
+    const projection = this.normalizeProjection(options.select);
+    if (projection) {
+      const rows = await this.prepareReadStmt(
+        `SELECT ${this.projectionSql(projection)} FROM ${quoteIdent(this.table)} WHERE ${where} ${order}${limit}${offset}`,
+      ).all<ProjectedSqliteDocumentRow>(...params);
+      return rows.map((row) => this.fromProjectedRow(row, projection));
+    }
+    const rows = await this.prepareReadStmt(
+      `SELECT * FROM ${quoteIdent(this.table)} WHERE ${where} ${order}${limit}${offset}`,
+    ).all<SqliteDocumentRow>(...params);
     return rows.map((row) => this.hydrate(this.fromRow(row)));
   }
 
@@ -664,14 +672,13 @@ export class SqliteDocumentStore {
     const limit = limitValue ? ` LIMIT ${limitValue}` : "";
     const offset = skipValue ? ` OFFSET ${skipValue}` : "";
     const order = options.sample ? "ORDER BY random()" : `ORDER BY ${this.compiler.orderBy(options.sort ?? undefined)}`;
-    const rows = await this.owner
-      .getConnection()
-      .prepare(`SELECT "id" FROM ${quoteIdent(this.table)} WHERE ${where} ${order}${limit}${offset}`)
-      .all<{ id: string }>(...params);
+    const rows = await this.prepareReadStmt(
+      `SELECT "id" FROM ${quoteIdent(this.table)} WHERE ${where} ${order}${limit}${offset}`,
+    ).all<{ id: string }>(...params);
     return rows.map((row) => row.id);
   }
 
-  async findOne(query?: DocumentQuery, options: { sort?: SortOption; skip?: number | null; sample?: boolean } = {}) {
+  async findOne(query?: DocumentQuery, options: FindOneOptions = {}) {
     return (await this.find(query, { ...options, limit: 1, sample: options.sample ? 1 : undefined })).at(0) ?? null;
   }
 
@@ -679,7 +686,7 @@ export class SqliteDocumentStore {
     return (await this.findIds(query, { ...options, limit: 1, sample: options.sample ? 1 : undefined })).at(0) ?? null;
   }
 
-  async pickOne(query?: DocumentQuery, options: { sort?: SortOption; skip?: number | null; sample?: boolean } = {}) {
+  async pickOne(query?: DocumentQuery, options: FindOneOptions = {}) {
     const doc = await this.findOne(query, options);
     if (!doc) throw new Error(`No Document (${this.table}): ${JSON.stringify(query)}`);
     return doc;
@@ -697,10 +704,9 @@ export class SqliteDocumentStore {
 
   async count(query?: DocumentQuery) {
     const { where, params } = this.safeQuery(query);
-    const row = await this.owner
-      .getConnection()
-      .prepare(`SELECT count(*) as count FROM ${quoteIdent(this.table)} WHERE ${where}`)
-      .get<{ count: number }>(...params);
+    const row = await this.prepareReadStmt(
+      `SELECT count(*) as count FROM ${quoteIdent(this.table)} WHERE ${where}`,
+    ).get<{ count: number }>(...params);
     return row?.count ?? 0;
   }
 
@@ -901,6 +907,55 @@ export class SqliteDocumentStore {
     };
   }
 
+  private normalizeProjection(select: ProjectionOption): string[] | null {
+    if (!select) return null;
+    const fields = Object.entries(select)
+      .filter(([, included]) => included)
+      .map(([field]) => field);
+    if (!fields.length) return null;
+    return [...new Set(fields.filter((field) => field !== "_doc"))];
+  }
+
+  private projectionSql(fields: string[]) {
+    const jsonFields = fields.filter((field) => !BASE_COLUMNS.has(field));
+    const baseColumns = [...BASE_COLUMNS].map((field) => quoteIdent(field));
+    const jsonColumns = jsonFields.map(
+      (field, idx) => `${this.compiler.fieldExpr(field)} AS ${quoteIdent(this.projectionAlias(idx))}`,
+    );
+    return [...baseColumns, ...jsonColumns].join(", ");
+  }
+
+  private projectionAlias(idx: number) {
+    return `__akan_projection_${idx}`;
+  }
+
+  private fromProjectedRow(row: ProjectedSqliteDocumentRow, fields: string[]) {
+    const doc: DocumentRecord = {
+      id: row.id,
+      createdAt: Number(row.createdAt),
+      updatedAt: Number(row.updatedAt),
+      removedAt: row.removedAt ? Number(row.removedAt) : undefined,
+    };
+    const jsonFields = fields.filter((field) => !BASE_COLUMNS.has(field));
+    for (const [idx, field] of jsonFields.entries()) {
+      const value = this.parseProjectedValue(row[this.projectionAlias(idx)]);
+      const props = (this.database.doc[FIELD_META] as unknown as FieldMap)[field]?.getProps?.();
+      doc[field] = props ? this.decodeFieldValue(value, props) : value;
+    }
+    return doc;
+  }
+
+  private parseProjectedValue(value: unknown) {
+    if (typeof value !== "string") return value;
+    const trimmed = value.trim();
+    if (!trimmed || (trimmed[0] !== "{" && trimmed[0] !== "[")) return value;
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+
   private decodeDocumentPayload(payload: Record<string, unknown>) {
     const fields = this.database.doc[FIELD_META] as unknown as FieldMap;
     return Object.fromEntries(
@@ -1011,6 +1066,19 @@ export class SqliteDocumentStore {
     return this.#insertStmt;
   }
 
+  private prepareReadStmt(sql: string) {
+    const cached = this.#readStmtCache.get(sql);
+    if (cached) return cached;
+    
+    if (this.#readStmtCache.size >= 128) {
+      const oldest = this.#readStmtCache.keys().next().value;
+      if (oldest) this.#readStmtCache.delete(oldest);
+    }
+    const stmt = this.owner.getConnection().prepare(sql);
+    this.#readStmtCache.set(sql, stmt);
+    return stmt;
+  }
+
   private assertValidRefName(refName: string) {
     if (!REF_NAME_RE.test(refName) || RESERVED_RE.test(refName))
       throw new Error(`Invalid database identifier: ${refName}`);

package/service/predefinedAdaptor/solidSqlite.ts

@@ -19,7 +19,7 @@ export interface SolidEnv extends BaseEnv {
   solid?: SolidConfig;
 }
 
-export type SolidValueType = "string" | "number" | "buffer";
+export type SolidValueType = "string" | "number" | "buffer" | "json";
 
 const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -62,19 +62,19 @@ export const openSolidDatabase = async (config: Required<SolidConfig>) => {
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 };
 
-export const encodeSolidValue = (value: string | number | Buffer): { type: SolidValueType; value: string | Buffer } => {
+export const encodeSolidValue = (value: unknown): { type: SolidValueType; value: string | Buffer } => {
   if (Buffer.isBuffer(value)) return { type: "buffer", value };
   if (typeof value === "number") return { type: "number", value: String(value) };
-  return { type: "string", value };
+  if (typeof value === "string") return { type: "string", value };
+
+  return { type: "json", value: JSON.stringify(value ?? null) };
 };
 
-export const decodeSolidValue = <T extends string | number | Buffer>(
-  type: SolidValueType,
-  value: string | Buffer | null,
-): T | undefined => {
+export const decodeSolidValue = <T>(type: SolidValueType, value: string | Buffer | null): T | undefined => {
   if (value === null) return undefined;
   if (type === "buffer") return Buffer.isBuffer(value) ? (value as T) : (Buffer.from(value) as T);
   if (type === "number") return Number(value) as T;
+  if (type === "json") return JSON.parse(typeof value === "string" ? value : value.toString()) as T;
   return String(value) as T;
 };