akanjs 3.0.0-alpha.46 → 3.0.0-alpha.47

package/base/baseEnv.ts

@@ -73,15 +73,18 @@ export type ClientEnv = BaseEnv & {
 
 let cachedEnv: ClientEnv | undefined;
 
+const missingPublicEnv = (key: string) =>
+  `getEnv() cannot run at build time: akan build does not inject ${key}. Call it from a runtime function instead of at module scope (e.g. env(() => getEnv()) in adapt(), a method body, or a default thunk).`;
+
 /** Reads and caches Akan runtime environment values from process/browser environment settings. */
 export const getEnv = (): ClientEnv => {
   if (cachedEnv) return cachedEnv;
   const appName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
   const repoName = process.env.AKAN_PUBLIC_REPO_NAME ?? "unknown";
   const serveDomain = process.env.AKAN_PUBLIC_SERVE_DOMAIN ?? "unknown";
-  if (appName === "unknown") throw new Error("environment variable AKAN_PUBLIC_APP_NAME is required");
-  if (repoName === "unknown") throw new Error("environment variable AKAN_PUBLIC_REPO_NAME is required");
-  if (serveDomain === "unknown") throw new Error("environment variable AKAN_PUBLIC_SERVE_DOMAIN is required");
+  if (appName === "unknown") throw new Error(missingPublicEnv("AKAN_PUBLIC_APP_NAME"));
+  if (repoName === "unknown") throw new Error(missingPublicEnv("AKAN_PUBLIC_REPO_NAME"));
+  if (serveDomain === "unknown") throw new Error(missingPublicEnv("AKAN_PUBLIC_SERVE_DOMAIN"));
   const environment = (process.env.AKAN_PUBLIC_ENV ?? "debug") as BaseEnv["environment"];
   const operationMode = (process.env.AKAN_PUBLIC_OPERATION_MODE ??
     (environment === "local" ? "local" : "cloud")) as BaseEnv["operationMode"];

package/constant/via.ts

@@ -430,10 +430,14 @@ declare global {
 }
 
 const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldObject): ConstantCls<Model> => {
-  const defaultValue = getDefault(model[FIELD_META]);
+
+  let defaultValue: DefaultOf<Model> | undefined;
   Object.assign(model, {
     purify: makePurify(model),
-    getDefault: () => ({ ...defaultValue }),
+    getDefault: () => {
+      defaultValue ??= getDefault<Model>(model[FIELD_META]);
+      return { ...defaultValue };
+    },
   });
   Object.entries(fieldMap).forEach(([, field]) => {
     if (field.enum) model.enums.add(field.enum);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.46",
+  "version": "3.0.0-alpha.47",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanApp.ts

@@ -37,7 +37,6 @@ interface ChildState {
 
 interface GatewayWsData {
   childIdx: number;
-  socketId: string;
   upstream: WebSocket;
 }
 
@@ -582,8 +581,8 @@ export class AkanApp {
     const upstreamWs = new WebSocket(`ws://${upstream.host}:${upstream.port}${url.pathname}${url.search}`, {
       headers: this.#makeProxyHeaders(req, child.idx),
     } as unknown as string[]);
-    const socketId = crypto.randomUUID();
-    const upgraded = server.upgrade(req, { data: { childIdx: child.idx, socketId, upstream: upstreamWs } });
+
+    const upgraded = server.upgrade(req, { data: { childIdx: child.idx, upstream: upstreamWs } });
     if (!upgraded) {
       upstreamWs.close();
       return new Response("WebSocket upgrade failed", { status: 500 });

package/server/routing/appWsData.ts

@@ -41,10 +41,17 @@ export class AppWsData {
   account?: unknown;
   /** The `authorization` value `account` was resolved from, so each frame need not re-verify it. */
   resolvedAuthorization?: string;
-  socketId?: string;
+  /**
+   * Identity of this connection, minted here so every app socket carries one from its first frame and
+   * adaptors and endpoints only ever read it. Per-connection and process-local — a reconnect gets a new
+   * one, and the federation gateway's own socket is a different one — so it is never a caller identity.
+   * It outlives a credential swap on purpose: the socket is still the same socket.
+   */
+  socketId: string;
   constructor(headers: Headers) {
     this.createdAt = Date.now();
     this.headers = headers;
     this.cookies = new Bun.CookieMap(headers.get("cookie") ?? "");
+    this.socketId = Bun.randomUUIDv7();
   }
 }

package/service/predefinedAdaptor/solidPubsub.adaptor.ts

@@ -3,9 +3,13 @@ import { adapt } from "../adapt";
 import { sendAkanIpc } from "../ipcTypes";
 import type { WebsocketAdaptor, WsRedisEventHandler, WsSocketData } from "./websocket.adaptor";
 
-const getSocketId = (ws: Bun.ServerWebSocket<unknown>, serverId: string) => {
+/**
+ * `AppWsData` mints the id at the handshake, so this reads it; the fallback only covers a socket that
+ * was upgraded outside the app router, where nothing else would have given it one.
+ */
+const getSocketId = (ws: Bun.ServerWebSocket<unknown>) => {
   const data = ws.data as WsSocketData;
-  if (!data.socketId) data.socketId = `${serverId}-${Bun.randomUUIDv7()}`;
+  data.socketId ??= Bun.randomUUIDv7();
   return data.socketId;
 };
 
@@ -64,7 +68,7 @@ export class SolidPubSub
   }
 
   async joinRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void> {
-    const socketId = getSocketId(ws, this.serverId);
+    const socketId = getSocketId(ws);
     const rooms = this.#socketRooms.get(socketId) ?? new Set<string>();
     rooms.add(room);
     this.#socketRooms.set(socketId, rooms);
@@ -72,7 +76,7 @@ export class SolidPubSub
   }
 
   async leaveRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void> {
-    const socketId = getSocketId(ws, this.serverId);
+    const socketId = getSocketId(ws);
     const rooms = this.#socketRooms.get(socketId);
     rooms?.delete(room);
     if (!rooms || rooms.size === 0) this.#socketRooms.delete(socketId);
@@ -80,7 +84,7 @@ export class SolidPubSub
   }
 
   async leaveAllRooms(ws: Bun.ServerWebSocket<unknown>): Promise<void> {
-    const socketId = getSocketId(ws, this.serverId);
+    const socketId = getSocketId(ws);
     const rooms = this.#socketRooms.get(socketId);
     if (rooms) {
       for (const room of rooms) sendAkanIpc({ type: "pubsub.unsubscribe", roomId: room, socketId, pid: process.pid });
@@ -89,7 +93,7 @@ export class SolidPubSub
   }
 
   async registerSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void> {
-    getSocketId(ws, this.serverId);
+    getSocketId(ws);
   }
 
   async unregisterSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void> {

package/service/predefinedAdaptor/websocket.adaptor.ts

@@ -209,9 +209,14 @@ export class WebSocketRedisAdaptor
     await pipeline.exec();
   }
 
+  /**
+   * `AppWsData` mints the id at the handshake, so this reads it; the fallback only covers a socket that
+   * was upgraded outside the app router. The owning server is recorded in the socket hash below, so the
+   * id itself carries no prefix.
+   */
   #getSocketId(ws: Bun.ServerWebSocket<unknown>): string {
     const data = ws.data as WsSocketData;
-    if (!data.socketId) data.socketId = `${this.serverId}-${Bun.randomUUIDv7()}`;
+    data.socketId ??= Bun.randomUUIDv7();
     return data.socketId;
   }
 

package/service/serve.ts

@@ -12,7 +12,7 @@ import {
 import type { DatabaseService, DatabaseServiceForModel } from "./types";
 
 interface ServiceOptions {
-  enabled?: boolean;
+  enabled?: boolean | (() => boolean);
   serverMode?: "batch" | "federation";
 }
 export type ServiceType = "database" | "plain";
@@ -102,9 +102,10 @@ export function serve(
     ...(typeof optionOrInjectBuilder === "function" && injectBuilderOrExtendSrv ? [injectBuilderOrExtendSrv] : []),
     ...extendSrvs,
   ] as ServiceCls[];
-  const isEnabled =
+  const enabledOption =
     option.enabled ??
     (!option.serverMode || process.env.SERVER_MODE === option.serverMode || process.env.SERVER_MODE === "all");
+  let enabledCache: boolean | undefined;
   const serviceType = typeof refNameOrDb === "string" ? "plain" : "database";
   const injectInfoMap = injectBuilder(injectionBuilder(refName));
   if (serviceType === "database")
@@ -115,7 +116,12 @@ export function serve(
   const srvRef = class Service {
     static readonly type = serviceType;
     static readonly refName = refName;
-    static enabled = isEnabled;
+    static get enabled() {
+      
+      if (enabledCache === undefined)
+        enabledCache = typeof enabledOption === "function" ? enabledOption() : enabledOption;
+      return enabledCache;
+    }
     static get name() {
       return `${capitalize(refName)}Service`;
     }

package/signal/internalArg.ts

@@ -21,15 +21,20 @@ export class Res implements InternalArg {
   }
 }
 
-/** Injects websocket state and subscription hooks into message/pubsub handlers. */
+/**
+ * Injects websocket state, this connection's id, and subscription hooks into message/pubsub handlers.
+ * `socketId` is the one `AppWsData` minted at the handshake, so a handler never reads `ws.data` to
+ * tell two callers apart — and never mints an id of its own, which would not match the room bookkeeping.
+ */
 export class Ws implements InternalArg {
   onDisconnect?: () => void;
   onUnsubscribe?: () => void;
   getArg(context: SignalContext) {
-    const webSocketContext = context.getWebSocketContext();
+    const webSocketContext = context.getWebSocketContext<{ socketId: string }>();
     const ws = webSocketContext.ws;
     return {
       ws,
+      socketId: ws.data.socketId,
       subscribe: webSocketContext.eventType === "subscribe",
       on: webSocketContext.on,
       off: webSocketContext.off,

package/types/server/routing/appWsData.d.ts

@@ -19,6 +19,12 @@ export declare class AppWsData {
     account?: unknown;
     /** The `authorization` value `account` was resolved from, so each frame need not re-verify it. */
     resolvedAuthorization?: string;
-    socketId?: string;
+    /**
+     * Identity of this connection, minted here so every app socket carries one from its first frame and
+     * adaptors and endpoints only ever read it. Per-connection and process-local — a reconnect gets a new
+     * one, and the federation gateway's own socket is a different one — so it is never a caller identity.
+     * It outlives a credential swap on purpose: the socket is still the same socket.
+     */
+    socketId: string;
     constructor(headers: Headers);
 }

package/types/service/serve.d.ts

@@ -4,7 +4,7 @@ import type { DatabaseModel } from "akanjs/document";
 import { type ExtractInjectInfoObject, type InjectBuilder, InjectInfo } from "./injectInfo.d.ts";
 import type { DatabaseServiceForModel } from "./types.d.ts";
 interface ServiceOptions {
-    enabled?: boolean;
+    enabled?: boolean | (() => boolean);
     serverMode?: "batch" | "federation";
 }
 export type ServiceType = "database" | "plain";

package/types/signal/internalArg.d.ts

@@ -18,12 +18,19 @@ export declare class Res implements InternalArg {
         redirect(url: string | URL, status?: number): Response;
     };
 }
-/** Injects websocket state and subscription hooks into message/pubsub handlers. */
+/**
+ * Injects websocket state, this connection's id, and subscription hooks into message/pubsub handlers.
+ * `socketId` is the one `AppWsData` minted at the handshake, so a handler never reads `ws.data` to
+ * tell two callers apart — and never mints an id of its own, which would not match the room bookkeeping.
+ */
 export declare class Ws implements InternalArg {
     onDisconnect?: () => void;
     onUnsubscribe?: () => void;
     getArg(context: SignalContext): {
-        ws: Bun.ServerWebSocket<unknown>;
+        ws: Bun.ServerWebSocket<{
+            socketId: string;
+        }>;
+        socketId: string;
         subscribe: boolean;
         on: (event: "disconnect" | "unsubscribe", handler: () => void) => void;
         off: (event: "disconnect" | "unsubscribe", handler: () => void) => void;