akanjs 0.0.1 → 2.0.0-beta.1

package/server/resolver/service.resolver.ts

@@ -0,0 +1,176 @@
+import type { PromiseOrObject } from "akanjs/base";
+import { capitalize } from "akanjs/common";
+import type { ConstantModel, QueryOf } from "akanjs/constant";
+import {
+  type CRUDEventType,
+  type DatabaseModel,
+  type DataInputOf,
+  type Doc,
+  documentQueryHelper,
+  type FindQueryOption,
+  getFilterInfoByKey,
+  getFilterMeta,
+  type ListQueryOption,
+  type SaveEventType,
+} from "akanjs/document";
+import type { DatabaseService, ServiceCls } from "akanjs/service";
+
+export class ServiceResolver {
+  static #getDefaultDbServiceMethods(className: string) {
+    const dbServiceMethods = {
+      async __get(this: DatabaseService, id: string) {
+        return await this.__databaseModel.__get(id);
+      },
+      async [`get${className}`](this: DatabaseService, id: string) {
+        return this.__get(id);
+      },
+      async __load(this: DatabaseService, id?: string) {
+        return await this.__databaseModel.__load(id);
+      },
+      async [`load${className}`](this: DatabaseService, id?: string) {
+        return this.__load(id);
+      },
+      async __loadMany(this: DatabaseService, ids: string[]) {
+        return await this.__databaseModel.__loadMany(ids);
+      },
+      async [`load${className}Many`](this: DatabaseService, ids: string[]) {
+        return this.__loadMany(ids);
+      },
+      async __list(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
+        return await this.__databaseModel.__list(query, queryOption);
+      },
+      async __listIds(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
+        return await this.__databaseModel.__listIds(query, queryOption);
+      },
+      async __find(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__find(query, queryOption);
+      },
+      async __findId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__findId(query, queryOption);
+      },
+      async __pick(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__pick(query, queryOption);
+      },
+      async __pickId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__pickId(query, queryOption);
+      },
+      async __exists(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__exists(query);
+      },
+      async __count(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__count(query);
+      },
+      async __insight(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__insight(query);
+      },
+      listenPre(
+        this: DatabaseService,
+        type: SaveEventType,
+        listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>,
+      ) {
+        return this.__databaseModel.listenPre(type, listener);
+      },
+      listenPost(
+        this: DatabaseService,
+        type: SaveEventType,
+        listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>,
+      ) {
+        return this.__databaseModel.listenPost(type, listener);
+      },
+      async __create(this: DatabaseService, data: DataInputOf) {
+        const input = await this.__libsPreCreate(data);
+        const doc = await this.__databaseModel.__create(input);
+        return await this.__libsPostCreate(doc);
+      },
+      async [`create${className}`](this: DatabaseService, data: DataInputOf) {
+        return this.__create(data);
+      },
+      async __update(this: DatabaseService, id: string, data: DataInputOf) {
+        const input = await this.__libsPreUpdate(id, data);
+        const doc = await this.__databaseModel.__update(id, input);
+        return await this.__libsPostUpdate(doc);
+      },
+      async [`update${className}`](this: DatabaseService, id: string, data: DataInputOf) {
+        return this.__update(id, data);
+      },
+      async __remove(this: DatabaseService, id: string): Promise<Doc> {
+        await this.__libsPreRemove(id);
+        const doc = await this.__databaseModel.__remove(id);
+        return await this.__libsPostRemove(doc);
+      },
+      async [`remove${className}`](this: DatabaseService, id: string): Promise<Doc> {
+        return this.__remove(id);
+      },
+    };
+    return dbServiceMethods;
+  }
+  static resolveDatabaseService(constant: ConstantModel, database: DatabaseModel, srvRef: ServiceCls): ServiceCls {
+    const className = capitalize(database.refName);
+    Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(className));
+    const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
+      const lastArg = args.at(-1);
+      const hasQueryOption =
+        lastArg &&
+        typeof lastArg === "object" &&
+        (typeof lastArg.select === "object" ||
+          typeof lastArg.skip === "number" ||
+          typeof lastArg.limit === "number" ||
+          typeof lastArg.sort === "string");
+      const queryFn = getFilterInfoByKey(database.filter, queryKey).queryFn;
+      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
+      const query = queryFn(...(hasQueryOption ? args.slice(0, -1) : args), documentQueryHelper);
+      const queryOption = hasQueryOption ? lastArg : {};
+      return { query, queryOption };
+    };
+    const filterMeta = getFilterMeta(database.filter);
+    const queryKeys = Object.keys(filterMeta.query);
+    queryKeys.forEach((queryKey) => {
+      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
+      const queryFn = filterInfo.queryFn;
+      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
+      const capitalizedQueryKey = capitalize(queryKey);
+      Object.assign(srvRef.prototype, {
+        [`list${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return this.__list(query, queryOption);
+        },
+        [`listIds${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return this.__listIds(query, queryOption);
+        },
+        [`find${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return this.__find(query, queryOption);
+        },
+        [`findId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return this.__findId(query, queryOption);
+        },
+        [`pick${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return this.__pick(query, queryOption);
+        },
+        [`pickId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return this.__pickId(query, queryOption);
+        },
+        [`exists${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return this.__exists(query);
+        },
+        [`count${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return this.__count(query);
+        },
+        [`insight${capitalize(queryKey)}`]: async function (this: DatabaseService, ...args: any) {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return this.__insight(query);
+        },
+        [`query${capitalize(queryKey)}`]: function (this: DatabaseService, ...args: any) {
+          return queryFn(...args, documentQueryHelper);
+        },
+      });
+    });
+    return srvRef;
+  }
+}

package/server/resolver/signal.resolver.ts

@@ -0,0 +1,386 @@
+import { type BaseEnv, type Cls, ENDPOINT_META, getEnv, ID, INTERNAL_META, Int, SLICE_META } from "akanjs/base";
+import { capitalize, Logger } from "akanjs/common";
+import { serialize } from "akanjs/constant";
+import { documentQueryHelper } from "akanjs/document";
+import {
+  type AkanJobOptions,
+  type InjectRegistry,
+  type LiveRegistry,
+  type WebsocketAdaptor,
+  WebsocketAdaptorRole,
+} from "akanjs/service";
+import { type Endpoint, type EndpointCls, sliceEndpoint } from "../../signal/endpoint";
+import type { EndpointInfo } from "../../signal/endpointInfo";
+import type { Internal, InternalCls } from "../../signal/internal";
+import type { InternalInfo } from "../../signal/internalInfo";
+import type { MiddlewareCls } from "../../signal/middleware";
+import type { ServerSignal, ServerSignalCls } from "../../signal/serverSignal";
+import { SignalContext, type WebSocketExecutionContext } from "../../signal/signalContext";
+import type { SliceCls } from "../../signal/slice";
+import type { SliceInfo } from "../../signal/sliceInfo";
+import type { WebsocketMessageData, WebsocketSubscribeAck } from "../../signal/types";
+import type { HttpRoutes, SignalRoutes, WebsocketRoutes } from "../types";
+
+export class SignalResolver {
+  static logger = new Logger("SignalResolver");
+
+  static makeRoomId(key: string, args: unknown[]) {
+    return `${key}${args.length ? "-" : ""}${args.join("-")}`;
+  }
+  static #localPublish: (roomId: string, data: object | object[]) => void = () => {
+    SignalResolver.logger.warn(`Local publish is not initialized yet`);
+  };
+  static setLocalPublish(localPublish: (roomId: string, data: object | object[]) => void, websocket: WebsocketAdaptor) {
+    SignalResolver.#localPublish = localPublish;
+    websocket.setEventHandler((roomId, data) => localPublish(roomId, data as object | object[]));
+  }
+  static resolveServerSignal(
+    serverSignalCls: ServerSignalCls,
+    { registry, live }: { registry: InjectRegistry; live: LiveRegistry },
+  ): ServerSignalCls {
+    const endpointMeta = serverSignalCls[ENDPOINT_META] as { [key: string]: EndpointInfo };
+    const internalMeta = serverSignalCls[INTERNAL_META] as { [key: string]: InternalInfo };
+    const websocket = SignalResolver.#getWebsocket(registry);
+    Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
+      if (endpointInfo.type !== "pubsub") throw new Error(`Endpoint ${key} is not a pubsub endpoint`);
+      websocket.registerEndpoint(key, endpointInfo.returns.returnRef as Cls, endpointInfo.returns.arrDepth);
+      const serializeFn = (data: unknown) =>
+        serialize(endpointInfo.returns.returnRef, endpointInfo.returns.arrDepth, data, "object", {
+          nullable: endpointInfo.returns.nullable,
+        });
+      Object.assign(serverSignalCls.prototype, {
+        [key]: async function (this: ServerSignal, ...args: any) {
+          const roomArgs = args.slice(0, -1);
+          const data = args.at(-1);
+          const resolvedData = await SignalContext.resolveReturn(data, {
+            signalContext: null,
+            returnRef: endpointInfo.returns.returnRef,
+            arrDepth: endpointInfo.returns.arrDepth,
+            registry,
+            live,
+          });
+          const serializedData = serializeFn(resolvedData) as object | object[] | null;
+          if (!serializedData) {
+            this.logger.warn(`Failed to serialize data for ${key}`);
+            return;
+          }
+          const roomId = SignalResolver.makeRoomId(key, roomArgs);
+          websocket.publish(roomId, serializedData);
+          SignalResolver.#localPublish(roomId, serializedData);
+        },
+      });
+    });
+    Object.entries(internalMeta).forEach(([key, internalInfo]) => {
+      if (internalInfo.type !== "process") throw new Error(`Internal ${key} is not a process internal`);
+      const argLength = internalInfo.args.length;
+      Object.assign(serverSignalCls.prototype, {
+        [key]: async function (this: ServerSignal, ...args: [...args: any, jobOptions?: AkanJobOptions]) {
+          const serverArgs = args.slice(0, argLength);
+          const jobOptions = args.at(argLength) as AkanJobOptions | undefined;
+          return await this.queue.registerProcessQueue(key, serverArgs, jobOptions);
+        },
+      });
+    });
+    return serverSignalCls;
+  }
+  static resolveSchedule(internalCls: InternalCls, internal: Internal, serverMode: "federation" | "batch" | "all") {
+    const internalMeta = internalCls[INTERNAL_META] as { [key: string]: InternalInfo };
+    Object.entries(internalMeta).forEach(([key, internalInfo]) => {
+      const { enabled, operationMode, serverMode: targetServerMode } = internalInfo.signalOption;
+      if (!enabled) return;
+      else if (operationMode && !operationMode.includes(getEnv().operationMode)) return;
+      else if (
+        targetServerMode &&
+        targetServerMode !== "all" &&
+        serverMode !== "all" &&
+        targetServerMode !== serverMode
+      )
+        return;
+      switch (internalInfo.type) {
+        case "process":
+          if (!internalInfo.execFn) throw new Error(`Exec function is not set for ${key}`);
+          internal.queue.registerProcessWorker(key, internalInfo.execFn.bind(internal));
+          break;
+        case "init":
+          internal.schedule.registerInit(key, () => internalInfo.execFn?.bind(internal)());
+          break;
+        case "destroy":
+          internal.schedule.registerDestroy(key, () => internalInfo.execFn?.bind(internal)());
+          break;
+        case "interval":
+          if (!internalInfo.signalOption.scheduleTime) throw new Error(`Schedule time is not set for ${key}`);
+          if (!internalInfo.execFn) throw new Error(`Exec function is not set for ${key}`);
+          internal.schedule.registerInterval(
+            key,
+            internalInfo.signalOption.scheduleTime,
+            internalInfo.execFn.bind(internal),
+            { lock: internalInfo.signalOption.lock },
+          );
+          break;
+        case "timeout":
+          if (!internalInfo.signalOption.scheduleTime) throw new Error(`Schedule time is not set for ${key}`);
+          if (!internalInfo.execFn) throw new Error(`Exec function is not set for ${key}`);
+          internal.schedule.registerTimeout(
+            key,
+            internalInfo.signalOption.scheduleTime,
+            internalInfo.execFn.bind(internal),
+          );
+          break;
+        case "cron":
+          if (!internalInfo.signalOption.scheduleCron) throw new Error(`Schedule cron is not set for ${key}`);
+          if (!internalInfo.execFn) throw new Error(`Exec function is not set for ${key}`);
+          internal.schedule.registerCron(
+            key,
+            internalInfo.signalOption.scheduleCron,
+            internalInfo.execFn.bind(internal),
+            { lock: internalInfo.signalOption.lock },
+          );
+          break;
+      }
+    });
+  }
+  static resolveSlice(sliceCls: SliceCls): EndpointCls {
+    const sliceMeta = sliceCls[SLICE_META] as { [key: string]: SliceInfo };
+    const cnst = sliceCls.srv.cnst;
+    if (!cnst) throw new Error("Constant is not set for slice");
+    const refName = cnst.refName;
+    const serviceName = `${refName}Service`;
+    const capitalizedRefName = capitalize(refName);
+
+    class SliceEndpoint extends sliceEndpoint(sliceCls.srv, (builder) => {
+      const endpointObj: { [key: string]: EndpointInfo } = {};
+      Object.entries(sliceMeta).forEach(([key, sliceInfo]) => {
+        if (!sliceInfo.execFn) return;
+        const capitalizedKey = capitalize(key);
+        const argLength = sliceInfo.args.length;
+
+        const listKey = `${refName}List${capitalizedKey}`;
+        endpointObj[listKey] = (builder as any)
+          .query([sliceInfo.light], sliceInfo.signalOption)
+          ._addArgs(sliceInfo.args)
+          .search("skip", Int)
+          .search("limit", Int)
+          .search("sort", String)
+          ._addInternalArgs(sliceInfo.internalArgs)
+          .exec(async function (this: any, ...requestArgs: any) {
+            const args = requestArgs.slice(0, argLength);
+            const skip = Number(requestArgs[argLength] ?? 0);
+            const limit = Number(requestArgs[argLength + 1] ?? 20);
+            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;
+          });
+
+        const insightKey = `${refName}Insight${capitalizedKey}`;
+        endpointObj[insightKey] = (builder as any)
+          .query(sliceInfo.insight, sliceInfo.signalOption)
+          ._addArgs(sliceInfo.args)
+          ._addInternalArgs(sliceInfo.internalArgs)
+          .exec(async function (this: any, ...requestArgs: any) {
+            const args = requestArgs.slice(0, argLength);
+            const internalArgs = requestArgs.slice(argLength);
+            const query = await sliceInfo.execFn?.apply(this, [...args, ...internalArgs, documentQueryHelper]);
+            return await this[serviceName].__insight(query);
+          });
+      });
+
+      endpointObj[refName] = (builder as any)
+        .query(cnst.full, { guards: sliceCls.getGuards })
+        .param(`${refName}Id`, ID)
+        .exec(async function (this: any, id: string) {
+          return await this[serviceName][`get${capitalizedRefName}`](id);
+        });
+
+      endpointObj[`light${capitalizedRefName}`] = (builder as any)
+        .query(cnst.light, { guards: sliceCls.getGuards })
+        .param(`${refName}Id`, ID)
+        .exec(async function (this: any, id: string) {
+          return await this[serviceName][`get${capitalizedRefName}`](id);
+        });
+
+      endpointObj[`create${capitalizedRefName}`] = (builder as any)
+        .mutation(cnst.full, { guards: sliceCls.cruGuards })
+        .body("data", cnst.input)
+        .exec(async function (this: any, data: any) {
+          return await this[serviceName].__create(data);
+        });
+
+      endpointObj[`update${capitalizedRefName}`] = (builder as any)
+        .mutation(cnst.full, { guards: sliceCls.cruGuards })
+        .param(`${refName}Id`, ID)
+        .body("data", cnst.input)
+        .exec(async function (this: any, id: string, data: any) {
+          return await this[serviceName].__update(id, data);
+        });
+
+      endpointObj[`remove${capitalizedRefName}`] = (builder as any)
+        .mutation(cnst.full, { guards: sliceCls.cruGuards })
+        .param(`${refName}Id`, ID)
+        .exec(async function (this: any, id: string) {
+          return await this[serviceName].__remove(id);
+        });
+      return endpointObj;
+    }) {}
+    return SliceEndpoint;
+  }
+  static #liveWsPubsubRoomCtx = new WeakMap<
+    Bun.ServerWebSocket<unknown>,
+    Map<string, SignalContext<WebSocketExecutionContext>>
+  >();
+  static resolveEndpoint(
+    endpointCls: EndpointCls,
+    endpoint: Endpoint,
+    {
+      registry,
+      env,
+      live,
+      middleware,
+    }: { registry: InjectRegistry; env: BaseEnv; live: LiveRegistry; middleware: Map<string, MiddlewareCls> },
+  ): SignalRoutes {
+    const endpointMeta = endpointCls[ENDPOINT_META] as { [key: string]: EndpointInfo };
+    const routes: HttpRoutes = {};
+    const routeOptions: NonNullable<SignalRoutes["routeOptions"]> = {};
+    const wsRoutes: WebsocketRoutes = {};
+    const defaultPrefix = endpointCls.srv.cnst?.refName;
+    Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
+      const servicePrefix = SignalResolver.#resolveServicePrefix(endpointInfo.signalOption.prefix, defaultPrefix);
+      const path = `${servicePrefix}${endpointInfo.getPath(key)}`;
+      if (endpointInfo.signalOption.globalPrefix !== undefined) {
+        routeOptions[path] = { globalPrefix: endpointInfo.signalOption.globalPrefix };
+      }
+      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();
+              }),
+          };
+          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();
+              }),
+          };
+          break;
+        case "pubsub":
+          wsRoutes[key] = async (ws, message, event) => {
+            const websocket = SignalResolver.#getWebsocket(registry);
+            const context = await new SignalContext(
+              key,
+              { ws, data: message, eventType: event ?? "unsubscribe" },
+              { endpointInfo, adaptor: endpoint, registry, env, live, middleware },
+            ).init();
+            const subscribe = event === "subscribe";
+            const roomId = context.getRoomId(key);
+            if (subscribe) {
+              await context.exec();
+              ws.subscribe(roomId);
+              const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws) ?? new Map();
+              roomCtxMap.set(roomId, context);
+              SignalResolver.#liveWsPubsubRoomCtx.set(ws, roomCtxMap);
+              
+              websocket.joinRoom(ws, roomId);
+              SignalResolver.logger.verbose(`WebSocket subscribed to room ${roomId}`);
+            } else {
+              ws.unsubscribe(roomId);
+              const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
+              if (roomCtxMap) {
+                const roomCtx = roomCtxMap.get(roomId);
+                if (roomCtx) {
+                  const unsubscribeHandlers = [...roomCtx.getWebSocketContext().onUnsubscribe.values()];
+                  await Promise.all(unsubscribeHandlers.map((handler) => handler()));
+                }
+                roomCtxMap.delete(roomId);
+                if (roomCtxMap.size === 0) SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
+                
+                websocket.leaveRoom(ws, roomId);
+                SignalResolver.logger.verbose(`WebSocket unsubscribed from room ${roomId}`);
+              }
+            }
+            const subscribeAck: WebsocketSubscribeAck = { type: "sub", roomId, subscribe };
+            return subscribeAck;
+          };
+          break;
+        case "message":
+          wsRoutes[key] = async (ws, message) => {
+            const context = await new SignalContext(
+              key,
+              { ws, data: message, eventType: "message" },
+              { endpointInfo, adaptor: endpoint, registry, env, live, middleware },
+            ).init();
+            const result = (await context.exec()) as object | object[];
+            const messageData: WebsocketMessageData = { type: "msg", key, data: result };
+            return messageData;
+          };
+          break;
+        default:
+          throw new Error(`Endpoint ${key} is not a valid endpoint type`);
+      }
+      SignalResolver.logger.verbose(`Resolved endpoint ${endpointInfo.type} ${path} for ${key}`);
+    });
+    return { routes, wsRoutes, routeOptions };
+  }
+
+  static #resolveServicePrefix(prefix: false | string | undefined, defaultPrefix?: string): string {
+    if (prefix === false || prefix === "") return "";
+    const resolved = prefix ?? defaultPrefix;
+    if (!resolved) return "";
+    const trimmed = resolved.trim().replace(/^\/+|\/+$/g, "");
+    return trimmed ? `/${trimmed}` : "";
+  }
+
+  static async handleWsOpen(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry) {
+    await SignalResolver.#getWebsocket(registry).registerSocket(ws);
+  }
+
+  static async handleWsClose(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry) {
+    const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
+    if (roomCtxMap) {
+      const unsubscribeHandlers = [...roomCtxMap.values()].flatMap((roomCtx) => [
+        ...roomCtx.getWebSocketContext().onUnsubscribe.values(),
+      ]);
+      await Promise.all(unsubscribeHandlers.map((handler) => handler()));
+      const disconnectHandlers = [...roomCtxMap.values()].flatMap((roomCtx) => [
+        ...roomCtx.getWebSocketContext().onDisconnect.values(),
+      ]);
+      await Promise.all(disconnectHandlers.map((handler) => handler()));
+    }
+    SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
+
+    await SignalResolver.#getWebsocket(registry).unregisterSocket(ws);
+    SignalResolver.logger.verbose(`WebSocket disconnected from all rooms`);
+  }
+  static #getWebsocket(registry: InjectRegistry): WebsocketAdaptor {
+    const roleProvider = [...registry.adaptorRole.entries()].find(
+      ([role]) => role.refName === WebsocketAdaptorRole.refName,
+    )?.[1];
+    const websocket =
+      (registry.adaptor.get(WebsocketAdaptorRole) as WebsocketAdaptor | undefined) ??
+      (roleProvider ? (registry.adaptor.get(roleProvider) as WebsocketAdaptor | undefined) : undefined) ??
+      ([...registry.adaptor.entries()].find(([adaptorCls]) =>
+        ["solidPubsub", "wsRedis"].includes(adaptorCls.refName),
+      )?.[1] as WebsocketAdaptor | undefined);
+    if (!websocket) throw new Error("WebSocket adaptor is not registered");
+    return websocket;
+  }
+}

package/server/robots.ts

@@ -0,0 +1,32 @@
+const DEFAULT_DISALLOW_PATHS = ["/api", "/_akan", "/admin", "/manager", "/private"] as const;
+
+const DEFAULT_AI_CRAWLERS = [
+  "GPTBot",
+  "ChatGPT-User",
+  "CCBot",
+  "ClaudeBot",
+  "Claude-Web",
+  "anthropic-ai",
+  "Google-Extended",
+  "PerplexityBot",
+  "Perplexity-User",
+  "Bytespider",
+  "Amazonbot",
+  "Applebot-Extended",
+  "Meta-ExternalAgent",
+  "FacebookBot",
+  "Diffbot",
+  "Omgilibot",
+  "Omgili",
+] as const;
+
+export function createDefaultRobotsTxt(): string {
+  const lines = [
+    "User-agent: *",
+    "Allow: /",
+    ...DEFAULT_DISALLOW_PATHS.map((path) => `Disallow: ${path}`),
+    "",
+    ...DEFAULT_AI_CRAWLERS.flatMap((crawler) => [`User-agent: ${crawler}`, "Disallow: /", ""]),
+  ];
+  return `${lines.join("\n").trimEnd()}\n`;
+}

package/server/routeElementComposer.tsx

@@ -0,0 +1,91 @@
+import type { Head, PathRoute, RouteRender } from "akanjs/client";
+import { Children, cloneElement, isValidElement, type ReactElement, type ReactNode, Suspense } from "react";
+
+export class RouteElementComposer {
+  static compose({
+    pathRoute,
+    params,
+    searchParams,
+  }: {
+    pathRoute: PathRoute;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+  }): ReactNode {
+    const renders = [...pathRoute.renderRootLayouts, ...pathRoute.renderLayouts, pathRoute.renderPage];
+    let element: ReactNode = null;
+    for (let i = renders.length - 1; i >= 0; i--) {
+      const routeRender = renders[i];
+      if (!routeRender) continue;
+      element = (
+        <Suspense fallback={RouteElementComposer.#composeLoadingFallback(renders.slice(i), params)}>
+          <RouteElementComposer.AsyncRender routeRender={routeRender} params={params} searchParams={searchParams}>
+            {element}
+          </RouteElementComposer.AsyncRender>
+        </Suspense>
+      );
+    }
+    return element;
+  }
+
+  static async resolveHead({
+    pathRoute,
+    params,
+    searchParams,
+  }: {
+    pathRoute: PathRoute;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+  }): Promise<Head | null | undefined> {
+    return pathRoute.resolveHead?.({ params, searchParams });
+  }
+
+  static async renderAsync({
+    routeRender,
+    children,
+    params,
+    searchParams,
+  }: {
+    routeRender: RouteRender;
+    children: ReactNode;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+  }) {
+    const node = await routeRender.render({ children, params, searchParams } as never);
+    return RouteElementComposer.#normalizeReactNode(node);
+  }
+
+  static AsyncRender = (props: {
+    routeRender: RouteRender;
+    children: ReactNode;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+  }) => RouteElementComposer.renderAsync(props);
+
+  static #normalizeReactNode(node: ReactNode): ReactNode {
+    if (Array.isArray(node)) return Children.toArray(node).map(RouteElementComposer.#normalizeReactNode);
+    if (!isValidElement(node)) return node;
+
+    const props = node.props as { children?: ReactNode };
+    if (!("children" in props)) return node;
+
+    const normalizedChildren = RouteElementComposer.#normalizeReactChildren(props.children);
+    if (normalizedChildren === props.children) return node;
+
+    return cloneElement(node as ReactElement<{ children?: ReactNode }>, undefined, normalizedChildren);
+  }
+
+  static #normalizeReactChildren(children: ReactNode): ReactNode {
+    if (Array.isArray(children)) return Children.toArray(children).map(RouteElementComposer.#normalizeReactNode);
+    return RouteElementComposer.#normalizeReactNode(children);
+  }
+
+  static #composeLoadingFallback(renders: RouteRender[], params: Record<string, string>): ReactNode {
+    let element: ReactNode = null;
+    for (let i = renders.length - 1; i >= 0; i--) {
+      const Loading = renders[i]?.Loading;
+      if (!Loading) continue;
+      element = Loading({ params, children: element } as never) as ReactNode;
+    }
+    return element;
+  }
+}