akanjs 2.0.5 → 2.0.7

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;
 };
 

package/service/predefinedAdaptor/storage.adaptor.ts

@@ -16,6 +16,7 @@ export interface UploadRequest {
   meta?: { [key: string]: string };
   rename?: string;
   host?: string;
+  access?: "public" | "private";
 }
 export interface CopyRequest {
   bucket: string;
@@ -29,6 +30,7 @@ export interface UploadFromStreamRequest {
   body: ReadableStream;
   mimetype: string;
   root?: string;
+  access?: "public" | "private";
   updateProgress: (progress: { loaded?: number; total?: number; part?: number }) => void;
   uploadSuccess: (url: string) => void;
 }
@@ -47,17 +49,22 @@ export interface StorageAdaptor {
   saveData(request: DownloadRequest): Promise<LocalFilePath>;
   copyData(request: CopyRequest): Promise<string>;
   deleteData(url: string): Promise<boolean>;
+  deleteDataByPath(path: string): Promise<boolean>;
 }
 
 export interface BlobStorageOptions extends BaseEnv {
-  blobStorage?: { baseDir?: string; urlPrefix?: string };
+  blobStorage?: { baseDir?: string; privateBaseDir?: string; urlPrefix?: string };
 }
 
 export class BlobStorage
   extends adapt("blobStorage", ({ env }) => ({
     root: env(
       ({ appName, blobStorage = { baseDir: "local", urlPrefix: "/backend/localFile/getBlob" } }: BlobStorageOptions) =>
-        `${process.env.AKAN_WORKSPACE_ROOT ?? "."}/${blobStorage.baseDir}/${appName}/backend`,
+        `${process.env.AKAN_WORKSPACE_ROOT ?? "."}/${blobStorage.baseDir ?? "local"}/${appName}/backend`,
+    ),
+    privateRoot: env(
+      ({ appName, blobStorage = { privateBaseDir: "local" } }: BlobStorageOptions) =>
+        `${process.env.AKAN_WORKSPACE_ROOT ?? "."}/${blobStorage.privateBaseDir ?? "local"}/${appName}/server-private`,
     ),
     urlPrefix: env(
       ({ blobStorage = { urlPrefix: "/backend/localFile/getBlob" } }: BlobStorageOptions) => blobStorage.urlPrefix,
@@ -68,12 +75,15 @@ export class BlobStorage
   #localPathToUrl(path: string) {
     return `${this.urlPrefix}/${path}`;
   }
+  #resolveFilePath(path: string) {
+    return path.startsWith("private/") ? `${this.privateRoot}/${path}` : `${this.root}/${path}`;
+  }
   async readData(path: string): Promise<ReadableStream> {
-    const filePath = `${this.root}/${path}`;
+    const filePath = this.#resolveFilePath(path);
     return Bun.file(filePath).stream();
   }
   async readDataAsJson<T>(path: string) {
-    const filePath = `${this.root}/${path}`;
+    const filePath = this.#resolveFilePath(path);
     return Bun.file(filePath).json() as T;
   }
   async getDataList(prefix?: string) {
@@ -81,14 +91,21 @@ export class BlobStorage
     const paths = Array.from(new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: false }));
     return paths.map((path) => this.#localPathToUrl(path));
   }
-  async uploadDataFromLocal({ path, localPath, meta }: UploadRequest) {
-    const filePath = `${this.root}/${path}`;
+  async uploadDataFromLocal({ path, localPath, meta, access = "public" }: UploadRequest) {
+    const filePath = access === "private" ? `${this.privateRoot}/${path}` : `${this.root}/${path}`;
     await Bun.write(filePath, Bun.file(localPath));
     if (meta) await Bun.write(`${filePath}.meta`, JSON.stringify(meta));
     return this.#localPathToUrl(path);
   }
-  async uploadDataFromStream({ path, body, mimetype, updateProgress, uploadSuccess }: UploadFromStreamRequest) {
-    const filePath = `${this.root}/${path}`;
+  async uploadDataFromStream({
+    path,
+    body,
+    mimetype,
+    updateProgress,
+    uploadSuccess,
+    access = "public",
+  }: UploadFromStreamRequest) {
+    const filePath = access === "private" ? `${this.privateRoot}/${path}` : `${this.root}/${path}`;
     try {
       await Bun.write(filePath, new Response(body));
       uploadSuccess(this.#localPathToUrl(path));
@@ -106,12 +123,21 @@ export class BlobStorage
     await Bun.write(`${this.root}/${pastePath}`, Bun.file(`${this.root}/${copyPath}`));
     return pastePath;
   }
+  async deleteDataByPath(path: string) {
+    try {
+      await Bun.file(this.#resolveFilePath(path)).delete();
+      return true;
+    } catch (error) {
+      this.logger.error(error instanceof Error ? error.message : "Unknown error");
+      return false;
+    }
+  }
   async deleteData(url: string) {
     try {
       const basePath = this.#localPathToUrl("");
       if (!url.startsWith(basePath)) throw new Error("Invalid Base URL, Unable to delete data");
       const path = url.replace(basePath, "");
-      await Bun.file(`${this.root}/${path}`).delete();
+      await this.deleteDataByPath(path);
       return true;
     } catch (error) {
       this.logger.error(error instanceof Error ? error.message : "Unknown error");

package/service/serviceModule.ts

@@ -45,12 +45,7 @@ export class ServiceModel<
       this.cnst,
       this.db,
       Object.assign({}, this.srvMap, ...srvs.map((srv) => srv.srvMap)),
-    ) as unknown as ServiceModel<
-      Srv & MergeAllKeyOfObjects<SrvModules, "srv">,
-      CnstModel,
-      DbModel,
-      SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">
-    >;
+    ) as unknown as ServiceModel<Srv, CnstModel, DbModel, SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">>;
   }
 
   static getDefaultDbServiceMethods(className: string) {

package/signal/base.signal.ts

@@ -31,7 +31,7 @@ export class BaseEndpoint extends endpoint(srv.base, ({ query, mutation, message
 })) {}
 
 export class Base extends serverSignal(BaseEndpoint, BaseInternal) {}
-export const base = SignalRegistry.registerService(BaseInternal, BaseEndpoint, Base);
+export const base = SignalRegistry.registerService("base" as const, BaseInternal, BaseEndpoint, Base);
 
 const createBaseFetch = () => FetchClient.from(base);
 type BaseFetch = ReturnType<typeof createBaseFetch>;

package/signal/index.ts

@@ -15,4 +15,5 @@ export * from "./signalContext";
 export * from "./signalRegistry";
 export * from "./slice";
 export * from "./sliceInfo";
+export * from "./trace";
 export * from "./types";

package/signal/middleware.ts

@@ -2,6 +2,7 @@ import type { BaseEnv, Cls, PromiseOrObject } from "akanjs/base";
 import { type CacheAdaptor, CacheAdaptorRole } from "akanjs/service";
 import dayjs from "dayjs";
 import type { SignalContext } from "./signalContext";
+import { traceCache } from "./trace";
 
 export interface Middleware<Env extends BaseEnv = BaseEnv> {
   use(env: Env): PromiseOrObject<(context: SignalContext, next: () => Promise<unknown>) => PromiseOrObject<unknown>>;
@@ -52,12 +53,15 @@ export class Cache extends middleware("cache") {
       if (cached) {
         context.adaptor.logger.debug(`Cache hit ${context.key}`);
         try {
-          return JSON.parse(cached);
+          const parsed = JSON.parse(cached);
+          traceCache(true);
+          return parsed;
         } catch (parseError) {
           context.adaptor.logger.warn(`Cache parse error ${context.key}: ${String(parseError)}`);
           await cache.delete(topic, key);
         }
       }
+      traceCache(false);
 
       const result = await next();
 

package/signal/signalContext.ts

@@ -18,6 +18,7 @@ import type { Adaptor, AdaptorCls, DatabaseService, InjectRegistry, LiveRegistry
 import type { Internal, InternalCls, InternalInfo, MiddlewareCls } from ".";
 import type { EndpointInfo } from "./endpointInfo";
 import { Exception } from "./exception";
+import { isTraceEnabled, runWithTrace, SignalTrace, traceSpan } from "./trace";
 
 export type SignalTransportType = "http" | "websocket";
 
@@ -54,6 +55,7 @@ export class SignalContext<
   adaptor: Adaptor;
   args: unknown[] = [];
   internalArgs: unknown[] = [];
+  trace: SignalTrace | null = null;
   #registry: InjectRegistry;
   #env: Env;
   #live: LiveRegistry;
@@ -87,6 +89,7 @@ export class SignalContext<
     this.#env = env;
     this.#live = live;
     this.#middleware = middleware;
+    if (isTraceEnabled()) this.trace = new SignalTrace(key, endpointInfo.type);
   }
 
   getAdaptor<T extends Adaptor>(adaptorCls: AdaptorCls<T>): T {
@@ -97,11 +100,18 @@ export class SignalContext<
     return instance as T;
   }
   async init() {
-    this.args = await this.ctx.getArgs(this.endpointInfo);
+    if (this.trace) {
+      const start = performance.now();
+      this.args = await this.ctx.getArgs(this.endpointInfo);
+      this.trace.recordSpan("argParse", performance.now() - start);
+    } else {
+      this.args = await this.ctx.getArgs(this.endpointInfo);
+    }
     return this;
   }
   async #checkGuards() {
     const guards = this.endpointInfo.signalOption.guards ?? [];
+    if (guards.length === 0) return;
     for (const GuardCls of guards) {
       const guard = new GuardCls();
       const canPass = guard.canPass(this);
@@ -109,41 +119,72 @@ export class SignalContext<
     }
   }
   async exec() {
+    if (!this.trace) return await this.#exec();
+    return await runWithTrace(this.trace, async () => {
+      try {
+        return await this.#exec();
+      } finally {
+        this.trace?.finalize();
+      }
+    });
+  }
+  async #exec() {
     if (!this.endpointInfo.execFn) throw new Exception.Error("Exec function is not set");
-    const middlewares = [...this.#middleware.values(), ...(this.endpointInfo.signalOption.middlewares ?? [])];
+    const endpointMiddlewares = this.endpointInfo.signalOption.middlewares ?? [];
     const coreExec = async () => {
       if (!this.endpointInfo.execFn) throw new Exception.Error("Exec function is not set");
-      await this.#checkGuards();
-      this.internalArgs = await Promise.all(
-        this.endpointInfo.internalArgs.map((arg) => {
-          const argValue = new arg.argRef().getArg(this) ?? null;
-          if (argValue === null && !arg.option?.nullable)
-            throw new Exception.Unauthorized(`Internal Argument ${arg.argRef.name} is required`);
-          return argValue;
-        }),
+      if (this.trace) await traceSpan("guards", () => this.#checkGuards());
+      else await this.#checkGuards();
+      if (this.endpointInfo.internalArgs.length > 0) {
+        this.internalArgs = await Promise.all(
+          this.endpointInfo.internalArgs.map((arg) => {
+            const argValue = new arg.argRef().getArg(this) ?? null;
+            if (argValue === null && !arg.option?.nullable)
+              throw new Exception.Unauthorized(`Internal Argument ${arg.argRef.name} is required`);
+            return argValue;
+          }),
+        );
+      }
+      if (!this.trace) return await this.endpointInfo.execFn.call(this.adaptor, ...this.args, ...this.internalArgs);
+      return await traceSpan(
+        "handler",
+        async () => await this.endpointInfo.execFn?.call(this.adaptor, ...this.args, ...this.internalArgs),
       );
-      const result = await this.endpointInfo.execFn.call(this.adaptor, ...this.args, ...this.internalArgs);
-      return result;
     };
     let next = coreExec;
-    for (let i = middlewares.length - 1; i >= 0; i--) {
-      const MiddlewareCls = middlewares[i];
-      if (!MiddlewareCls) continue;
-      const middleware = new MiddlewareCls();
-      const currentNext = next;
-      next = async () => await (await middleware.use(this.getEnv()))(this, currentNext);
+    if (this.#middleware.size > 0 || endpointMiddlewares.length > 0) {
+      const middlewares = [...this.#middleware.values(), ...endpointMiddlewares];
+      for (let i = middlewares.length - 1; i >= 0; i--) {
+        const MiddlewareCls = middlewares[i];
+        if (!MiddlewareCls) continue;
+        const middleware = new MiddlewareCls();
+        const currentNext = next;
+        next = async () => await (await middleware.use(this.getEnv()))(this, currentNext);
+      }
     }
-    const result = await next();
+    const result = this.trace ? await traceSpan("execChain", () => next()) : await next();
     if (this.endpointInfo.type === "pubsub") return;
     if (result instanceof Response) return result;
-    const resolved = await SignalContext.resolveReturn(result, {
-      signalContext: this,
-      returnRef: this.endpointInfo.returns.returnRef,
-      arrDepth: this.endpointInfo.returns.arrDepth,
-      registry: this.#registry,
-      live: this.#live,
-    });
-    return this.ctx.makeResponse(resolved, this.endpointInfo);
+    if (!this.trace) {
+      const resolved = await SignalContext.resolveReturn(result, {
+        signalContext: this,
+        returnRef: this.endpointInfo.returns.returnRef,
+        arrDepth: this.endpointInfo.returns.arrDepth,
+        registry: this.#registry,
+        live: this.#live,
+      });
+      return this.ctx.makeResponse(resolved, this.endpointInfo);
+    }
+    const resolved = await traceSpan("resolveReturn", () =>
+      SignalContext.resolveReturn(result, {
+        signalContext: this,
+        returnRef: this.endpointInfo.returns.returnRef,
+        arrDepth: this.endpointInfo.returns.arrDepth,
+        registry: this.#registry,
+        live: this.#live,
+      }),
+    );
+    return await traceSpan("serialize", async () => this.ctx.makeResponse(resolved, this.endpointInfo));
   }
   static async try(
     endpoint: Adaptor,
@@ -257,6 +298,11 @@ export class SignalContext<
     service: DatabaseService,
     { arrDepth, nullable }: { arrDepth: number; nullable: boolean },
   ): Promise<unknown> {
+    if (value === null || value === undefined) {
+      if (nullable) return null;
+      throw new Error(`Document ${value} is not found`);
+    }
+    if (arrDepth > 0 && Array.isArray(value) && value.length === 0) return [];
     if (arrDepth === 0)
       return await service.__load(String(value)).then((doc) => {
         if (doc === null) {
@@ -300,19 +346,24 @@ export class SignalContext<
 export class HttpExecutionContext<Appended = unknown> {
   req: Bun.BunRequest & Appended;
   res = Response;
-  url: URL;
+  #url: URL | null = null;
   params: RuntimeRecord = {};
   searchParams: RuntimeRecord = {};
   body: RuntimeRecord = {};
   constructor(req: Bun.BunRequest) {
     this.req = req as Bun.BunRequest & Appended;
-    this.url = new URL(req.url);
+  }
+  get url() {
+    if (!this.#url) this.#url = new URL(this.req.url);
+    return this.#url;
   }
   async getArgs(endpointInfo: EndpointInfo): Promise<unknown[]> {
+    if (endpointInfo.args.length === 0) return [];
     this.params = this.req.params;
     
-    const hasUploadArgs = endpointInfo.args.some((arg) => arg.type === "body" && arg.argRef === Upload);
-    if (endpointInfo.type === "mutation" && this.req.body) {
+    const hasBodyArgs = endpointInfo.args.some((arg) => arg.type === "body");
+    const hasUploadArgs = hasBodyArgs && endpointInfo.args.some((arg) => arg.type === "body" && arg.argRef === Upload);
+    if (endpointInfo.type === "mutation" && hasBodyArgs && this.req.body) {
       if (hasUploadArgs) {
         const formData = await this.req.formData();
         this.body = {};
@@ -361,6 +412,9 @@ export class HttpExecutionContext<Appended = unknown> {
   }
   makeResponse(result: unknown, endpointInfo: EndpointInfo) {
     if (result instanceof Response) return result;
+    if (endpointInfo.returns.arrDepth === 0 && PrimitiveRegistry.has(endpointInfo.returns.returnRef as Cls)) {
+      return this.res.json(result);
+    }
     const value = serialize(endpointInfo.returns.returnRef, endpointInfo.returns.arrDepth, result, "object", {
       nullable: endpointInfo.returns.nullable,
     });