akanjs 2.2.4-rc.4 → 2.2.4

package/service/predefinedAdaptor/solidSqlite.test.ts

@@ -0,0 +1,457 @@
+import { Database, type SQLQueryBindings, type Statement } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+import { dayjs, Int } from "akanjs/base";
+import { ConstantRegistry, via } from "akanjs/constant";
+import { by, type DatabaseCls, DatabaseRegistry, DocumentSchema, from, into } from "akanjs/document";
+import { type AkanSqlClient, type AkanSqlStatement, SqliteDocumentStore } from "./database.adaptor";
+import { decodeSolidValue, encodeSolidValue, getSolidConfig, toEpochMs } from "./solidSqlite";
+import { resolveDefaultSqliteFile } from "./sqlitePath";
+
+const InsightTestStatus = ["active", "failed", "deploying"] as const;
+class InsightTestInput extends via((f) => ({
+  title: f(String),
+  score: f(Int, { default: 0 }),
+  status: f(String, { default: "active" }),
+  tags: f([String], { default: [] }),
+})) {}
+class InsightTestObject extends via(InsightTestInput, (f) => ({})) {}
+class InsightTestLight extends via(InsightTestObject, ["title"] as const, () => ({})) {}
+class InsightTestFull extends via(InsightTestObject, InsightTestLight, () => ({})) {}
+class InsightTestInsight extends via(InsightTestFull, (f) => ({
+  count: f(Int, { default: 0, accumulate: {} }),
+  activeCount: f(Int, { default: 0, accumulate: { status: "active" } }),
+  runningCount: f(Int, { default: 0, accumulate: { status: { oneOf: ["active", "deploying"] } } }),
+  taggedCount: f(Int, { default: 0, accumulate: { tags: { oneOf: ["featured", "urgent"] } } }),
+})) {}
+const insightTestConstant = ConstantRegistry.buildModel(
+  "sqliteInsightTest",
+  InsightTestInput,
+  InsightTestObject,
+  InsightTestFull,
+  InsightTestLight,
+  InsightTestInsight,
+  { InsightTestInput, InsightTestObject, InsightTestFull, InsightTestLight, InsightTestInsight, InsightTestStatus },
+);
+class InsightTestFilter extends from(InsightTestFull, () => ({})) {}
+class InsightTestDoc extends by(InsightTestFull) {}
+class InsightTestModel extends into(InsightTestDoc, InsightTestFilter, insightTestConstant, () => ({})) {}
+const insightTestDatabase = DatabaseRegistry.buildModel(
+  "sqliteInsightTest",
+  InsightTestInput as unknown as DatabaseCls<InstanceType<typeof InsightTestInput>>,
+  InsightTestDoc,
+  InsightTestModel,
+  InsightTestObject,
+  InsightTestInsight,
+  InsightTestFilter,
+);
+
+class TicketHistory extends via((f) => ({
+  action: f(String),
+  content: f([String], { default: [] }),
+  count: f(Int, { default: 0 }),
+  flag: f(Boolean, { default: false }),
+})) {}
+class TicketTestInput extends via((f) => ({
+  title: f(String),
+  status: f(String, { default: "active" }),
+  issuedAt: f(Date).optional(),
+  transactionAt: f(Date, { default: dayjs(0) }),
+  histories: f([TicketHistory]),
+})) {}
+class TicketTestObject extends via(TicketTestInput, (f) => ({})) {}
+class TicketTestLight extends via(TicketTestObject, ["title"] as const, () => ({})) {}
+class TicketTestFull extends via(TicketTestObject, TicketTestLight, () => ({})) {}
+class TicketTestInsight extends via(TicketTestFull, (f) => ({
+  count: f(Int, { default: 0, accumulate: {} }),
+})) {}
+const ticketTestConstant = ConstantRegistry.buildModel(
+  "sqliteTicketTest",
+  TicketTestInput,
+  TicketTestObject,
+  TicketTestFull,
+  TicketTestLight,
+  TicketTestInsight,
+  { TicketTestInput, TicketTestObject, TicketTestFull, TicketTestLight, TicketTestInsight, TicketHistory },
+);
+class TicketTestFilter extends from(TicketTestFull, () => ({})) {}
+class TicketTestDoc extends by(TicketTestFull) {}
+class TicketTestModel extends into(TicketTestDoc, TicketTestFilter, ticketTestConstant, () => ({})) {}
+const ticketTestDatabase = DatabaseRegistry.buildModel(
+  "sqliteTicketTest",
+  TicketTestInput as unknown as DatabaseCls<InstanceType<typeof TicketTestInput>>,
+  TicketTestDoc,
+  TicketTestModel,
+  TicketTestObject,
+  TicketTestInsight,
+  TicketTestFilter,
+);
+
+class TestSqliteStatement implements AkanSqlStatement {
+  constructor(private readonly statement: Statement) {}
+
+  async run(...params: unknown[]) {
+    return this.statement.run(...(params as SQLQueryBindings[]));
+  }
+
+  async get<Row = Record<string, unknown>>(...params: unknown[]): Promise<Row | null> {
+    return (this.statement.get(...(params as SQLQueryBindings[])) as Row | null) ?? null;
+  }
+
+  async all<Row = Record<string, unknown>>(...params: unknown[]): Promise<Row[]> {
+    return this.statement.all(...(params as SQLQueryBindings[])) as Row[];
+  }
+}
+
+class TestSqliteClient implements AkanSqlClient {
+  constructor(readonly db: Database) {}
+
+  async execute(sql: string, params: unknown[] | Record<string, unknown> = []) {
+    const values = Array.isArray(params) ? params : Object.values(params);
+    return this.db.query(sql).run(...(values as SQLQueryBindings[]));
+  }
+
+  prepare(sql: string): AkanSqlStatement {
+    return new TestSqliteStatement(this.db.query(sql));
+  }
+
+  async close() {
+    this.db.close();
+  }
+}
+
+class TestDatabaseOwner {
+  private readonly meta = new Map<string, string>();
+  readonly afterCommitCallbacks: (() => unknown)[] = [];
+
+  constructor(private readonly client: AkanSqlClient) {}
+
+  getConnection() {
+    return this.client;
+  }
+
+  getMeta(key: string) {
+    return this.meta.get(key);
+  }
+
+  setMeta(key: string, value: string) {
+    this.meta.set(key, value);
+  }
+
+  async afterCommit(fn: () => unknown) {
+    this.afterCommitCallbacks.push(fn);
+    await fn();
+  }
+}
+
+describe("solid sqlite utilities", () => {
+  test("encodes and decodes solid values", () => {
+    const buffer = Buffer.from("hello");
+
+    expect(encodeSolidValue("value")).toEqual({ type: "string", value: "value" });
+    expect(encodeSolidValue(12)).toEqual({ type: "number", value: "12" });
+    expect(encodeSolidValue(buffer)).toEqual({ type: "buffer", value: buffer });
+
+    expect(decodeSolidValue<string>("string", "value")).toBe("value");
+    expect(decodeSolidValue<number>("number", "12")).toBe(12);
+    expect(decodeSolidValue<Buffer>("buffer", buffer)).toEqual(buffer);
+    expect(decodeSolidValue<Buffer>("buffer", "hello")).toEqual(buffer);
+    expect(decodeSolidValue<string>("string", null)).toBeUndefined();
+  });
+
+  test("round-trips structured (object/array) solid values as json", () => {
+    // Refresh-session storage writes objects/arrays through the cache, which bun:sqlite
+    // cannot bind directly; they must be JSON-encoded so callers get the value back intact.
+    const session = { id: "s1", subject: "admin", expiresAt: "2026-01-01T00:00:00.000Z", userAgent: undefined };
+    const encodedObj = encodeSolidValue(session);
+    expect(encodedObj.type).toBe("json");
+    expect(typeof encodedObj.value).toBe("string");
+    expect(decodeSolidValue<typeof session>("json", encodedObj.value)).toEqual({
+      id: "s1",
+      subject: "admin",
+      expiresAt: "2026-01-01T00:00:00.000Z",
+    });
+
+    const hashes = ["a", "b", "c"];
+    const encodedArr = encodeSolidValue(hashes);
+    expect(encodedArr.type).toBe("json");
+    expect(decodeSolidValue<string[]>("json", encodedArr.value)).toEqual(hashes);
+
+    // Top-level undefined is coerced to JSON null rather than producing an invalid binding.
+    expect(encodeSolidValue(undefined)).toEqual({ type: "json", value: "null" });
+  });
+
+  test("converts optional expiration values to epoch ms", () => {
+    const date = dayjs("2026-01-01T00:00:00.000Z");
+
+    expect(toEpochMs()).toBeNull();
+    expect(toEpochMs(null)).toBeNull();
+    expect(toEpochMs(1234)).toBe(1234);
+    expect(toEpochMs(date)).toBe(date.valueOf());
+  });
+
+  test("resolves default sqlite paths and solid config", () => {
+    const previousSqliteDir = process.env.AKAN_SQLITE_DIR;
+    const previousSolidDbPath = process.env.AKAN_SOLID_DB_PATH;
+    const previousOperationMode = process.env.AKAN_PUBLIC_OPERATION_MODE;
+    try {
+      process.env.AKAN_SQLITE_DIR = "/tmp/akan-sqlite";
+      expect(
+        resolveDefaultSqliteFile({
+          appName: "demo",
+          fileName: "demo.db",
+          isProduction: false,
+          workspaceRoot: "/workspace",
+        }),
+      ).toBe("/tmp/akan-sqlite/demo.db");
+
+      delete process.env.AKAN_SQLITE_DIR;
+      expect(
+        resolveDefaultSqliteFile({
+          appName: "demo",
+          fileName: "demo.db",
+          isProduction: false,
+          workspaceRoot: "/workspace",
+        }),
+      ).toBe("/workspace/local/apps/demo/demo.db");
+
+      expect(
+        resolveDefaultSqliteFile({
+          appName: "demo",
+          fileName: "demo.db",
+          isProduction: true,
+          operationMode: "local",
+          workspaceRoot: "/workspace",
+        }),
+      ).toBe("/workspace/local/apps/demo/demo.db");
+
+      process.env.AKAN_PUBLIC_OPERATION_MODE = "local";
+      expect(
+        resolveDefaultSqliteFile({
+          appName: "demo",
+          fileName: "demo.db",
+          isProduction: true,
+          workspaceRoot: "/workspace",
+        }),
+      ).toBe("/workspace/local/apps/demo/demo.db");
+
+      expect(
+        resolveDefaultSqliteFile({
+          appName: "demo",
+          fileName: "demo.db",
+          isProduction: true,
+          operationMode: "cloud",
+          workspaceRoot: "/workspace",
+        }),
+      ).toBe(`${process.cwd()}/sqlite/demo.db`);
+
+      process.env.AKAN_SOLID_DB_PATH = "/tmp/solid.db";
+      expect(
+        getSolidConfig({
+          appName: "demo",
+          environment: "test",
+          solid: { queueLeaseMs: 7, journalMode: "MEMORY" },
+        }).filePath,
+      ).toBe("/tmp/solid.db");
+      expect(
+        getSolidConfig({
+          appName: "demo",
+          environment: "test",
+          solid: { queueLeaseMs: 7, journalMode: "MEMORY" },
+        }),
+      ).toMatchObject({
+        journalMode: "MEMORY",
+        queueLeaseMs: 7,
+        busyTimeoutMs: 5000,
+        synchronous: "NORMAL",
+      });
+    } finally {
+      if (previousSqliteDir === undefined) delete process.env.AKAN_SQLITE_DIR;
+      else process.env.AKAN_SQLITE_DIR = previousSqliteDir;
+      if (previousSolidDbPath === undefined) delete process.env.AKAN_SOLID_DB_PATH;
+      else process.env.AKAN_SOLID_DB_PATH = previousSolidDbPath;
+      if (previousOperationMode === undefined) delete process.env.AKAN_PUBLIC_OPERATION_MODE;
+      else process.env.AKAN_PUBLIC_OPERATION_MODE = previousOperationMode;
+    }
+  });
+
+  test("hydrates new documents with schema defaults before save", async () => {
+    const db = new Database(":memory:", { strict: true, create: true });
+    const client = new TestSqliteClient(db);
+    const owner = new TestDatabaseOwner(client);
+    const store = new SqliteDocumentStore(owner, insightTestConstant, insightTestDatabase, new DocumentSchema());
+
+    try {
+      await client.execute(
+        `CREATE TABLE IF NOT EXISTS "_akan_meta" ("key" TEXT PRIMARY KEY NOT NULL, "value" TEXT NOT NULL, "updatedAt" INTEGER NOT NULL)`,
+      );
+      await store.ensure();
+
+      const doc = store.hydrate({ title: "Draft" });
+
+      expect(doc.score).toBe(0);
+      expect(doc.status).toBe("active");
+      expect(doc.tags).toEqual([]);
+      await expect(doc.save()).resolves.toMatchObject({
+        title: "Draft",
+        score: 0,
+        status: "active",
+        tags: [],
+      });
+    } finally {
+      await client.close();
+    }
+  });
+
+  test("fills nested constant defaults inside arrays on save", async () => {
+    const db = new Database(":memory:", { strict: true, create: true });
+    const client = new TestSqliteClient(db);
+    const owner = new TestDatabaseOwner(client);
+    const store = new SqliteDocumentStore(owner, ticketTestConstant, ticketTestDatabase, new DocumentSchema());
+
+    try {
+      await client.execute(
+        `CREATE TABLE IF NOT EXISTS "_akan_meta" ("key" TEXT PRIMARY KEY NOT NULL, "value" TEXT NOT NULL, "updatedAt" INTEGER NOT NULL)`,
+      );
+      await store.ensure();
+
+      const created = await store.create({ title: "Ticket", histories: [{ action: "open" }] });
+      expect(created.histories[0]).toMatchObject({ action: "open", content: [], count: 0, flag: false });
+
+      created.histories.push({ action: "close" });
+      const saved = await created.save();
+      expect(saved.histories[1]).toMatchObject({ action: "close", content: [], count: 0, flag: false });
+
+      const fetched = await store.pickById(created.id);
+      expect(fetched.histories[0]).toMatchObject({ action: "open", content: [], count: 0, flag: false });
+      expect(fetched.histories[1]).toMatchObject({ action: "close", content: [], count: 0, flag: false });
+    } finally {
+      await client.close();
+    }
+  });
+
+  test("fills missing nested and top-level defaults when loading legacy rows", async () => {
+    const db = new Database(":memory:", { strict: true, create: true });
+    const client = new TestSqliteClient(db);
+    const owner = new TestDatabaseOwner(client);
+    const store = new SqliteDocumentStore(owner, ticketTestConstant, ticketTestDatabase, new DocumentSchema());
+
+    try {
+      await client.execute(
+        `CREATE TABLE IF NOT EXISTS "_akan_meta" ("key" TEXT PRIMARY KEY NOT NULL, "value" TEXT NOT NULL, "updatedAt" INTEGER NOT NULL)`,
+      );
+      await store.ensure();
+
+      const now = Date.now();
+      // Legacy row: nested `content`/`count`/`flag` and top-level `status` were never persisted.
+      const legacyDoc = JSON.stringify({ title: "Legacy", histories: [{ action: "open" }] });
+      await client.execute(
+        `INSERT INTO "sqliteTicketTest" ("id", "createdAt", "updatedAt", "removedAt", "_doc") VALUES (?, ?, ?, ?, ?)`,
+        ["legacy-1", now, now, null, legacyDoc],
+      );
+
+      const fetched = await store.pickById("legacy-1");
+      expect(fetched.status).toBe("active");
+      expect(fetched.histories[0]).toMatchObject({ action: "open", content: [], count: 0, flag: false });
+    } finally {
+      await client.close();
+    }
+  });
+
+  test("normalizes date fields to epoch storage regardless of input shape", async () => {
+    const db = new Database(":memory:", { strict: true, create: true });
+    const client = new TestSqliteClient(db);
+    const owner = new TestDatabaseOwner(client);
+    const store = new SqliteDocumentStore(owner, ticketTestConstant, ticketTestDatabase, new DocumentSchema());
+
+    try {
+      await client.execute(
+        `CREATE TABLE IF NOT EXISTS "_akan_meta" ("key" TEXT PRIMARY KEY NOT NULL, "value" TEXT NOT NULL, "updatedAt" INTEGER NOT NULL)`,
+      );
+      await store.ensure();
+
+      const iso = "2026-06-06T13:52:39.747Z";
+      // `issuedAt` arrives as an ISO string while `transactionAt` falls back to its dayjs(0) default.
+      const created = await store.create({ title: "Dated", issuedAt: iso, histories: [] });
+      expect(dayjs.isDayjs(created.issuedAt)).toBe(true);
+      expect(created.issuedAt.valueOf()).toBe(dayjs(iso).valueOf());
+      expect(created.transactionAt.valueOf()).toBe(0);
+
+      // Both dates must persist as epoch numbers, not a string/number mix.
+      const row = await client
+        .prepare(`SELECT "_doc" FROM "sqliteTicketTest" WHERE "id" = ?`)
+        .get<{ _doc: string }>(created.id);
+      const stored = JSON.parse(row?._doc ?? "{}");
+      expect(typeof stored.issuedAt).toBe("number");
+      expect(stored.issuedAt).toBe(dayjs(iso).valueOf());
+      expect(typeof stored.transactionAt).toBe("number");
+      expect(stored.transactionAt).toBe(0);
+
+      const fetched = await store.pickById(created.id);
+      expect(fetched.issuedAt.valueOf()).toBe(dayjs(iso).valueOf());
+      expect(fetched.transactionAt.valueOf()).toBe(0);
+    } finally {
+      await client.close();
+    }
+  });
+
+  test("reads legacy ISO-string dates as valid dayjs", async () => {
+    const db = new Database(":memory:", { strict: true, create: true });
+    const client = new TestSqliteClient(db);
+    const owner = new TestDatabaseOwner(client);
+    const store = new SqliteDocumentStore(owner, ticketTestConstant, ticketTestDatabase, new DocumentSchema());
+
+    try {
+      await client.execute(
+        `CREATE TABLE IF NOT EXISTS "_akan_meta" ("key" TEXT PRIMARY KEY NOT NULL, "value" TEXT NOT NULL, "updatedAt" INTEGER NOT NULL)`,
+      );
+      await store.ensure();
+
+      const iso = "2026-06-06T13:52:39.747Z";
+      const now = Date.now();
+      // Legacy row persisted `issuedAt` as an ISO string instead of epoch ms.
+      const legacyDoc = JSON.stringify({ title: "Legacy", issuedAt: iso, histories: [] });
+      await client.execute(
+        `INSERT INTO "sqliteTicketTest" ("id", "createdAt", "updatedAt", "removedAt", "_doc") VALUES (?, ?, ?, ?, ?)`,
+        ["legacy-date-1", now, now, null, legacyDoc],
+      );
+
+      const fetched = await store.pickById("legacy-date-1");
+      expect(fetched.issuedAt.isValid()).toBe(true);
+      expect(fetched.issuedAt.valueOf()).toBe(dayjs(iso).valueOf());
+    } finally {
+      await client.close();
+    }
+  });
+
+  test("counts insight fields with document query accumulates", async () => {
+    const db = new Database(":memory:", { strict: true, create: true });
+    const client = new TestSqliteClient(db);
+    const owner = new TestDatabaseOwner(client);
+    const store = new SqliteDocumentStore(owner, insightTestConstant, insightTestDatabase, new DocumentSchema());
+
+    try {
+      await client.execute(
+        `CREATE TABLE IF NOT EXISTS "_akan_meta" ("key" TEXT PRIMARY KEY NOT NULL, "value" TEXT NOT NULL, "updatedAt" INTEGER NOT NULL)`,
+      );
+      await store.ensure();
+      await store.create({ title: "Alpha", score: 12, status: "active", tags: ["featured"] });
+      await store.create({ title: "Beta", score: 4, status: "failed", tags: ["cold"] });
+      await store.create({ title: "Gamma", score: 20, status: "deploying", tags: ["urgent"] });
+
+      await expect(store.insight()).resolves.toEqual({
+        count: 3,
+        activeCount: 1,
+        runningCount: 2,
+        taggedCount: 2,
+      });
+      await expect(store.insight({ score: { gte: 10 } })).resolves.toEqual({
+        count: 2,
+        activeCount: 1,
+        runningCount: 2,
+        taggedCount: 2,
+      });
+    } finally {
+      await client.close();
+    }
+  });
+});

package/service/predefinedAdaptor/solidSqlite.ts

@@ -67,7 +67,8 @@ export const encodeSolidValue = (value: unknown): { type: SolidValueType; value:
   if (Buffer.isBuffer(value)) return { type: "buffer", value };
   if (typeof value === "number") return { type: "number", value: String(value) };
   if (typeof value === "string") return { type: "string", value };
-
+  // Objects, arrays, booleans, null: stored as JSON so callers can round-trip
+  // structured values (e.g. refresh sessions) through the SQLite-backed cache.
   return { type: "json", value: JSON.stringify(value ?? null) };
 };
 

package/service/predefinedAdaptor/websocket.adaptor.ts

@@ -63,7 +63,7 @@ export class WebSocketRedisAdaptor
   #heartbeatInterval: Timer | null = null;
 
   override async onInit() {
-    
+    // Publisher lifecycle
     this.publisher.on("connect", () => {
       this.#publisherReady = true;
       this.logger.verbose("Publisher connected");
@@ -77,6 +77,7 @@ export class WebSocketRedisAdaptor
       this.logger.warn(`Publisher error: ${err.message}`);
     });
 
+    // Subscriber lifecycle
     this.subscriber.on("error", (err: Error) => {
       this.logger.warn(`Subscriber error: ${err.message}`);
     });
@@ -84,6 +85,7 @@ export class WebSocketRedisAdaptor
     await this.publisher.connect();
     await this.subscriber.connect();
 
+    // Subscribe to broadcast channel
     await this.subscriber.subscribe(BROADCAST_CHANNEL, (err?: Error | null) => {
       if (err) this.logger.warn(`Subscribe error: ${err.message}`);
     });
@@ -105,6 +107,8 @@ export class WebSocketRedisAdaptor
       }
     });
 
+    // Server heartbeat — expire server key every 60s, refresh every 30s
+    // If a pod crashes without graceful shutdown, its keys expire after 60s
     await this.redis.set(`${WEBSOCKET_PREFIX}server:${this.serverId}`, Date.now().toString(), "EX", 60);
     this.#heartbeatInterval = setInterval(async () => {
       try {
@@ -119,12 +123,13 @@ export class WebSocketRedisAdaptor
   }
 
   override async onDestroy() {
-    
+    // Stop heartbeat
     if (this.#heartbeatInterval) {
       clearInterval(this.#heartbeatInterval);
       this.#heartbeatInterval = null;
     }
 
+    // Clean up all sockets registered to this server
     await this.#cleanupServer();
 
     if (this.subscriber) {
@@ -142,6 +147,8 @@ export class WebSocketRedisAdaptor
     this.logger.verbose("WebSocket Redis adaptor destroyed");
   }
 
+  // ── Pub/Sub ──
+
   publish(roomId: string, data: unknown): void {
     const endpointKey = this.#getEndpointKey(roomId);
     const endpointInfo = endpointKey ? this.#endpointMap.get(endpointKey) : null;
@@ -180,6 +187,8 @@ export class WebSocketRedisAdaptor
     return idx >= 0 ? roomId.substring(0, idx) : roomId;
   }
 
+  // ── Room membership ──
+
   async joinRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void> {
     const socketId = this.#getSocketId(ws);
     const pipeline = this.redis.multi();
@@ -209,6 +218,7 @@ export class WebSocketRedisAdaptor
     await pipeline.exec();
   }
 
+  // ── Socket registration ──
   #getSocketId(ws: Bun.ServerWebSocket<unknown>): string {
     const data = ws.data as WsSocketData;
     if (!data.socketId) data.socketId = `${this.serverId}-${Bun.randomUUIDv7()}`;
@@ -231,6 +241,8 @@ export class WebSocketRedisAdaptor
     await this.leaveAllRooms(ws);
   }
 
+  // ── Internal helpers ──
+
   #packMessage(origin: string, roomId: string, payload: Buffer): Buffer {
     const originBuf = Buffer.from(origin, "utf-8");
     const roomIdBuf = Buffer.from(roomId, "utf-8");
@@ -294,7 +306,7 @@ export class WebSocketRedisAdaptor
       const sockets = await this.redis.smembers(`${WEBSOCKET_PREFIX}server:${this.serverId}:sockets`);
       const pipeline = this.redis.multi();
       for (const socketId of sockets) {
-        
+        // Get rooms for each socket and remove from room sets
         const rooms = await this.redis.smembers(`${WEBSOCKET_PREFIX}socket:${socketId}:rooms`);
         for (const room of rooms) {
           pipeline.srem(`${WEBSOCKET_PREFIX}room:${room}`, socketId);

package/service/serve.ts

@@ -38,7 +38,7 @@ const avoidKeys = new Set([
 
 export interface Service {
   readonly logger: Logger;
-  
+  // readonly connection: Connection;
   onInit(): Promise<void>;
   _libsOnInit(): Promise<void>;
   onDestroy(): Promise<void>;
@@ -47,9 +47,9 @@ export interface Service {
 
 export type ServiceCls<
   RefName extends string = string,
-  
+  // biome-ignore lint/complexity/noBannedTypes: `{}` keeps generated service types from gaining object prototype keys.
   Methods = {},
-  
+  // biome-ignore lint/complexity/noBannedTypes: `{}` keeps services with no injections assignable.
   InjectMap extends { [key: string]: InjectInfo } = {},
 > = Cls<
   Methods & ExtractInjectInfoObject<InjectMap> & Service,
@@ -65,12 +65,14 @@ export function serve<RefName extends string, Injection extends InjectBuilder>(
   refName: RefName,
   injectBuilder: Injection,
   ...extendSrvs: Cls[]
+  // biome-ignore lint/complexity/noBannedTypes: `{}` preserves plain service method inference.
 ): ServiceCls<RefName, {}, ReturnType<Injection>>;
 export function serve<RefName extends string, Injection extends InjectBuilder>(
   refName: RefName,
   option: ServiceOptions,
   injectBuilder: Injection,
   ...extendSrvs: Cls[]
+  // biome-ignore lint/complexity/noBannedTypes: `{}` preserves plain service method inference.
 ): ServiceCls<RefName, {}, ReturnType<Injection>>;
 export function serve<
   T extends string,
@@ -153,8 +155,10 @@ export function serve(
     static [INJECT_META] = {};
     readonly logger = new Logger(this.constructor.name);
     async onInit() {
+      //
     }
     async onDestroy() {
+      //
     }
   };
   applyMixins(srvRef, extSrvs, avoidKeys);