akanjs 2.4.1 → 2.4.2-rc.1

package/client/csrTypes.ts

@@ -50,6 +50,13 @@ export interface PageConfig {
   rscPatchHeadSafe?: boolean;
   topSafeAreaColor?: string;
   bottomSafeAreaColor?: string;
+  /**
+   * Keeps the route out of `akan build`. The route still serves under `akan start`, but nothing about it
+   * reaches production: no bundle, no manifest entry, no URL. On a `_layout`, every route under that
+   * directory is excluded with it. Must be written as a literal `true`/`false` — the build reads it from
+   * the source without evaluating the module.
+   */
+  devOnly?: boolean;
 }
 
 export interface CsrState {

package/client/frameConfig.ts

@@ -24,6 +24,8 @@ const pageConfigKeys = new Set<keyof PageConfig>([
   "topSafeAreaColor",
   "bottomSafeAreaColor",
 ]);
+
+const buildPageConfigKeys = new Set<keyof PageConfig>(["devOnly"]);
 const transitionTypes = new Set<TransitionType>(["none", "fade", "bottomUp", "stack", "scaleOut"]);
 const ssrRenderModes = new Set<SsrRenderMode>(["stream", "block"]);
 const DEFAULT_BOOLEAN_INSET = 48;
@@ -38,10 +40,13 @@ export function validatePageConfig(routeKey: string, config?: PageConfig) {
   if (!isRecord(config)) throw new Error(`[route-convention] pageConfig in ${routeKey} must be an object.`);
   const pageConfig = config as PageConfig;
   for (const key of Object.keys(pageConfig)) {
-    if (!pageConfigKeys.has(key as keyof PageConfig)) {
+    if (!pageConfigKeys.has(key as keyof PageConfig) && !buildPageConfigKeys.has(key as keyof PageConfig)) {
       throw new Error(`[route-convention] unsupported pageConfig option "${key}" in ${routeKey}`);
     }
   }
+  if (pageConfig.devOnly !== undefined && typeof pageConfig.devOnly !== "boolean") {
+    throw new Error(`[route-convention] pageConfig.devOnly in ${routeKey} must be a boolean.`);
+  }
   if (pageConfig.transition !== undefined && !transitionTypes.has(pageConfig.transition)) {
     throw new Error(`[route-convention] unsupported pageConfig.transition "${pageConfig.transition}" in ${routeKey}`);
   }

package/client/rscNavigation.ts

@@ -1,5 +1,6 @@
 declare global {
   var __AKAN_RSC_CLEAR_CACHE__: (() => void) | undefined;
+  var __AKAN_RSC_IS_FROM_CACHE__: (() => boolean) | undefined;
   var __AKAN_RSC_NAVIGATE__:
     | ((href: string, options?: { replace?: boolean; scrollToTop?: boolean }) => Promise<void>)
     | undefined;
@@ -9,11 +10,19 @@ export const clearRscNavigationCache = () => {
   globalThis.__AKAN_RSC_CLEAR_CACHE__?.();
 };
 
+/**
+ * True when the page tree currently on screen was replayed from the RSC navigation cache instead of
+ * fetched from the server. Data hydrated out of such a payload can be arbitrarily old, so anything
+ * that must show current values should refetch.
+ */
+export const isRscNavigationFromCache = () => globalThis.__AKAN_RSC_IS_FROM_CACHE__?.() ?? false;
+
 export const navigateRsc = (href: string, options?: { replace?: boolean; scrollToTop?: boolean }) => {
   return globalThis.__AKAN_RSC_NAVIGATE__?.(href, options);
 };
 
 export const useRscNavigation = () => ({
   clearCache: clearRscNavigationCache,
+  isFromCache: isRscNavigationFromCache,
   navigate: navigateRsc,
 });

package/common/index.ts

@@ -54,3 +54,8 @@ export { sleep } from "./sleep";
 export { splitVersion } from "./splitVersion";
 export { getBasePathFromPathname, parseBasePaths } from "./subRoute";
 export type * from "./types";
+export {
+  type WebsocketAuthAckData,
+  type WebsocketAuthRequest,
+  websocketAuthContract,
+} from "./websocketAuth";

package/common/websocketAuth.ts

@@ -0,0 +1,24 @@
+export interface WebsocketAuthRequest {
+  key: string;
+  data: [string | null];
+}
+
+export interface WebsocketAuthAckData {
+  type: "auth";
+  revokedRooms: string[];
+}
+
+/**
+ * Framework-owned websocket auth contract shared by the client and the server dispatcher.
+ * The credential frame carries the raw bearer token; verifying it stays in userland middleware,
+ * so the server only swaps the credential snapshot held on the socket.
+ */
+export const websocketAuthContract = {
+  key: "__auth",
+  makeRequest: (jwt: string | null): WebsocketAuthRequest => ({ key: "__auth", data: [jwt] }),
+  makeAck: (revokedRooms: string[]): WebsocketAuthAckData => ({ type: "auth", revokedRooms }),
+  readJwt: (data: unknown): string | null => {
+    const jwt = Array.isArray(data) ? data[0] : null;
+    return typeof jwt === "string" && jwt.length > 0 ? jwt : null;
+  },
+} as const;

package/constant/fieldInfo.ts

@@ -17,6 +17,7 @@ import {
   type UnCls,
 } from "akanjs/base";
 import { ConstantRegistry } from "./constantRegistry";
+import type { TextFieldRole } from "./textFieldPaths";
 import type { BaseObject } from "./types";
 import type { ConstantModelRef } from "./via";
 
@@ -102,7 +103,7 @@ export interface ConstantFieldProps<
   example?: FieldValue;
   of?: MapValue; 
   validate?: (value: FieldValue, model: any) => boolean;
-  text?: "search" | "filter";
+  text?: TextFieldRole;
   meta?: Metadata;
 }
 export const fieldPresets = ["email", "password", "url"] as const;
@@ -192,7 +193,7 @@ interface ConstantFieldBuildProps<
   example?: FieldValue;
   of?: MapValue; 
   validate?: (value: FieldValue, model: any) => boolean;
-  text?: "search" | "filter";
+  text?: TextFieldRole;
   modelRef: ConstantModelRef;
   arrDepth: number;
   optArrDepth: number;
@@ -315,7 +316,7 @@ export class ConstantField<
   readonly example?: FieldValue;
   readonly of?: MapValue; 
   readonly validate?: (value: FieldValue, model: any) => boolean;
-  readonly text?: "search" | "filter";
+  readonly text?: TextFieldRole;
   readonly modelRef: ConstantModelRef;
   readonly arrDepth: number;
   readonly optArrDepth: number;

package/constant/index.ts

@@ -6,5 +6,7 @@ export * from "./getDefault";
 export * from "./immerify";
 export * from "./purify";
 export * from "./serialize";
+export * from "./textFieldPathSet";
+export * from "./textFieldPaths";
 export * from "./types";
 export * from "./via";

package/constant/textFieldPathSet.ts

@@ -0,0 +1,8 @@
+/** The `search_doc` columns a model feeds, each holding the document paths that write it. */
+export class TextFieldPathSet {
+  readonly title = new Set<string>();
+  readonly desc = new Set<string>();
+  readonly tag = new Set<string>();
+  readonly thumb = new Set<string>();
+  readonly filter = new Set<string>();
+}

package/constant/textFieldPaths.ts

@@ -0,0 +1,59 @@
+import { type Cls, PrimitiveRegistry, type PrimitiveScalar } from "akanjs/base";
+import type { ConstantField, FieldObject } from "./fieldInfo";
+import { TextFieldPathSet } from "./textFieldPathSet";
+
+/** Column a `text` field feeds in the `search_doc` mirror. */
+export const textFieldRoles = ["title", "desc", "tag", "thumb", "filter"] as const;
+export type TextFieldRole = (typeof textFieldRoles)[number];
+
+const refRoles = new Set<TextFieldRole>(["thumb", "filter"]);
+
+export class TextFieldPaths extends TextFieldPathSet {
+  readonly children = new TextFieldPathSet();
+
+  collect(fieldMap: FieldObject) {
+    for (const [key, field] of Object.entries(fieldMap)) {
+      if (field.text) {
+        this.#assertIndexable(key, field.text, field);
+        this[field.text].add(key);
+      }
+
+      if (field.isClass && field.isScalar) this.#mergeChild(key, field);
+    }
+    return this;
+  }
+
+  #mergeChild(key: string, parent: ConstantField) {
+    const child = parent.modelRef.text as TextFieldPaths;
+    for (const role of textFieldRoles) {
+      for (const path of [...child[role], ...child.children[role]]) {
+        this.#assertReachable(`${key}.${path}`, parent);
+        this.children[role].add(`${key}.${path}`);
+      }
+    }
+  }
+
+  #assertReachable(path: string, parent: ConstantField) {
+    if (parent.fieldType === "secret") throw new Error(`Text field "${path}" is under a secret field`);
+    if (parent.fieldType === "hidden") throw new Error(`Text field "${path}" is under a hidden field`);
+    if (parent.fieldType === "resolve") throw new Error(`Text field "${path}" is under a resolved field`);
+    if (parent.arrDepth > 1) throw new Error(`Text field "${path}" is under a nested array and cannot be indexed`);
+  }
+
+  #assertIndexable(key: string, role: TextFieldRole, field: ConstantField) {
+    
+    if (field.fieldType === "secret") throw new Error(`Text field "${key}" is secret and must not be indexed`);
+    if (field.fieldType === "hidden") throw new Error(`Text field "${key}" is hidden and must not be indexed`);
+    if (field.fieldType === "resolve") throw new Error(`Text field "${key}" is resolved and is absent from _doc`);
+    if (field.isMap) throw new Error(`Text field "${key}" is a Map and cannot be indexed`);
+    if (field.arrDepth > 1) throw new Error(`Text field "${key}" is a nested array and cannot be indexed`);
+    const modelRef = field.modelRef as unknown as Cls;
+    const refName = PrimitiveRegistry.has(modelRef)
+      ? PrimitiveRegistry.getName(modelRef as unknown as typeof PrimitiveScalar)
+      : null;
+    if (refName === "String") return;
+    if (refRoles.has(role) && (refName === "ID" || (field.isClass && !field.isScalar))) return;
+    const accepted = refRoles.has(role) ? "String, ID, or a model reference" : "String";
+    throw new Error(`Text field "${key}" declares text: "${role}", which accepts ${accepted}`);
+  }
+}

package/constant/types.ts

@@ -98,10 +98,6 @@ export interface ProtoPatch {
 }
 
 export const DEFAULT_PAGE_SIZE = 20;
-export interface TextDoc {
-  [key: string]: string | TextDoc;
-}
-
 export type NonFunctionalKeys<T> = {
   [K in keyof T]: T[K] extends (...args: never[]) => unknown ? never : K;
 }[keyof T];

package/constant/via.ts

@@ -26,6 +26,7 @@ import {
   resolve,
 } from "./fieldInfo";
 import { makePurify, type PurifiedModel, type PurifyFunc } from "./purify";
+import { TextFieldPaths } from "./textFieldPaths";
 import type { BaseInsight, BaseObject, ConstantType, DefaultOf, DefaultOfSchema, NonFunctionalKeys } from "./types";
 
 type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
@@ -191,8 +192,7 @@ const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "sca
   class BaseConstant {
     static readonly [FIELD_META]: FieldObject = field;
     static modelType: ConstantType = modelType;
-    static text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } } =
-      { search: new Set(), filter: new Set(), children: { search: new Set(), filter: new Set() } };
+    static text: TextFieldPaths = new TextFieldPaths();
     static children: Set<ConstantModelRef> = new Set();
     static relations: Set<ConstantModelRef> = new Set();
     static enums: Set<EnumInstance> = new Set();
@@ -268,7 +268,7 @@ export interface ConstantStatics<
   children: Set<ConstantModelRef>;
   relations: Set<ConstantModelRef>;
   enums: Set<EnumInstance>;
-  text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } };
+  text: TextFieldPaths;
   _OptionalKey: OptionalKey;
   _RelationKey: RelationKey;
   _PrimitiveKey: PrimitiveKey;
@@ -295,7 +295,7 @@ export interface DatabaseConstantStatics<Schema = any, FieldObj extends FieldObj
   children: Set<ConstantModelRef>;
   relations: Set<ConstantModelRef>;
   enums: Set<EnumInstance>;
-  text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } };
+  text: TextFieldPaths;
   _DatabaseSchema: {
     [K in keyof Schema]: K extends keyof FieldObj
       ? FieldObj[K]["fieldType"] extends "hidden"
@@ -317,7 +317,7 @@ export type ConstantModelRef<
     children: Set<ConstantModelRef>;
     relations: Set<ConstantModelRef>;
     enums: Set<EnumInstance>;
-    text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } };
+    text: TextFieldPaths;
   }
 >;
 
@@ -430,31 +430,16 @@ const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldO
     purify: makePurify(model),
     getDefault: () => ({ ...defaultValue }),
   });
-  Object.entries(fieldMap).forEach(([key, field]) => {
+  Object.entries(fieldMap).forEach(([, field]) => {
     if (field.enum) model.enums.add(field.enum);
-    if (field.text === "search") model.text.search.add(key);
-    else if (field.text === "filter") model.text.filter.add(key);
-    else if (field.isClass) {
-      if (field.isScalar) model.children.add(field.modelRef);
-      else model.relations.add(field.modelRef);
-      for (const child of field.modelRef.children) model.children.add(child);
-      for (const childEnum of field.modelRef.enums) model.enums.add(childEnum);
-      for (const relation of field.modelRef.relations) model.relations.add(relation);
-      for (const relationEnum of field.modelRef.enums) model.enums.add(relationEnum);
-      field.modelRef.text.search.forEach((subKey) => {
-        model.text.children.search.add(`${key}.${subKey}`);
-      });
-      field.modelRef.text.filter.forEach((subKey) => {
-        model.text.children.filter.add(`${key}.${subKey}`);
-      });
-      field.modelRef.text.children.search.forEach((subKey) => {
-        model.text.children.search.add(`${key}.${subKey}`);
-      });
-      field.modelRef.text.children.filter.forEach((subKey) => {
-        model.text.children.filter.add(`${key}.${subKey}`);
-      });
-    }
+    if (!field.isClass) return;
+    if (field.isScalar) model.children.add(field.modelRef);
+    else model.relations.add(field.modelRef);
+    for (const child of field.modelRef.children) model.children.add(child);
+    for (const childEnum of field.modelRef.enums) model.enums.add(childEnum);
+    for (const relation of field.modelRef.relations) model.relations.add(relation);
   });
+  model.text.collect(fieldMap);
   return model as unknown as ConstantCls<Model>;
 };
 

package/dictionary/dictInfo.ts

@@ -169,6 +169,10 @@ export class ModelDictInfo<
   } = {
     latest: FieldTranslation.translate(["Latest", "최신순"]).desc(["Latest", "최신순"]),
     oldest: FieldTranslation.translate(["Oldest", "오래된순"]).desc(["Oldest", "오래된순"]),
+    relevance: FieldTranslation.translate(["Relevance", "관련도순"]).desc([
+      "Best text-search match first",
+      "검색어와 가장 관련있는 순",
+    ]),
   };
   static getBaseSignalDictionary<T extends string>(refName: T): BaseModelCrudGetSignalTranslation<T, [string, string]> {
     const capRefName = capitalize(refName);

package/document/documentQuery.ts

@@ -23,12 +23,22 @@ export const isDocumentId = (value: unknown): value is DocumentId =>
 export type DocumentPrimitive = string | number | boolean | null | Dayjs | Date;
 export type DocumentPath<T = any> = Extract<keyof T, string> | (string & {});
 
+export const searchColumns = ["title", "desc", "tag", "filter"] as const;
+export type SearchColumn = (typeof searchColumns)[number];
+
+export interface DocumentSearchOptions {
+  columns?: SearchColumn[];
+  prefix?: boolean;
+  weights?: number[];
+}
+
 export type DocumentQueryNode =
   | { kind: "all"; queries: DocumentQuery[] }
   | { kind: "any"; queries: DocumentQuery[] }
   | { kind: "not"; query: DocumentQuery }
   | { kind: "op"; op: DocumentQueryOperator; value?: unknown }
-  | { kind: "raw"; sql: string; params: unknown[] };
+  | { kind: "raw"; sql: string; params: unknown[] }
+  | ({ kind: "search"; text: string } & DocumentSearchOptions);
 
 export type DocumentQueryOperator =
   | "eq"
@@ -152,6 +162,12 @@ export const createDocumentQueryHelper = () => ({
   has: (value: unknown) => op("has", value),
   contains: (value: unknown) => op("contains", value),
   raw: (sql: string, params: unknown[] = []): DocumentQueryNode => ({ kind: "raw", sql, params }),
+
+  search: (text: string, options: DocumentSearchOptions = {}): DocumentQueryNode => ({
+    kind: "search",
+    text,
+    ...options,
+  }),
   when: (condition: unknown, query: DocumentQuery): DocumentQuery => (condition ? query : {}),
 });
 

package/document/documentSchema.ts

@@ -7,15 +7,14 @@ export type DocumentHookName = `before${Capitalize<SaveEventType>}` | `after${Ca
 
 export interface DocumentIndexDescriptor {
   name?: string;
+
   fields: Record<string, 1 | -1 | "text" | boolean>;
   unique?: boolean;
-  text?: boolean;
   where?: DocumentQuery;
 }
 
 export interface DocumentIndexBuilder<Schema> {
   path(path: string, order?: 1 | -1): DocumentIndexBuilder<Schema>;
-  text(path: string): DocumentIndexBuilder<Schema>;
   unique(): DocumentIndexBuilder<Schema>;
   where(where: DocumentQuery | ((q: DocumentQueryHelper) => DocumentQuery)): DocumentIndexBuilder<Schema>;
   done(): Schema;
@@ -58,14 +57,6 @@ export class DocumentSchema<Doc = unknown> {
     return this;
   }
 
-  text(...fields: string[]) {
-    this.indexes.push({
-      text: true,
-      fields: Object.fromEntries(fields.map((field) => [field, "text" as const])),
-    });
-    return this;
-  }
-
   createIndex(name: string): DocumentIndexBuilder<this> {
     const schema = this;
     const descriptor: DocumentIndexDescriptor = { name, fields: {} };
@@ -74,11 +65,6 @@ export class DocumentSchema<Doc = unknown> {
         descriptor.fields[path] = order;
         return api;
       },
-      text(path: string) {
-        descriptor.fields[path] = "text";
-        descriptor.text = true;
-        return api;
-      },
       unique() {
         descriptor.unique = true;
         return api;

package/document/filterMeta.ts

@@ -98,7 +98,7 @@ export const fillMissingFilterArgs = (filterInfo: FilterInfo, args: unknown[]) =
   return [...args, ...Array(filterInfo.args.length - args.length).fill(undefined)];
 };
 
-export type BaseFilterSortKey = "latest" | "oldest";
+export type BaseFilterSortKey = "latest" | "oldest" | "relevance";
 export type BaseFilterQueryKey = "any";
 export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;
 
@@ -130,6 +130,8 @@ interface BaseQuery<Model> {
 interface BaseSort {
   latest: { createdAt: -1 };
   oldest: { createdAt: 1 };
+
+  relevance: Record<string, never>;
 }
 type LibFilterQuery<LibFilters extends FilterCls[]> = MergeAllDoubleKeyOfObjects<
   LibFilters,
@@ -189,7 +191,7 @@ export const from = <
         any: filter().query((_q) => ({ removedAt: { empty: true } })),
         ...querySort.query,
       },
-      sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, querySort.sort),
+      sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 }, relevance: {} }, querySort.sort),
     },
     ...libFilterRefs.map((libFilterRef) => getFilterMeta(libFilterRef)),
   );

package/fetch/client/fetchClient.ts

@@ -197,6 +197,7 @@ export class FetchClient {
   }
   setJwt(jwt: string | null) {
     this.jwt = jwt;
+    this.ws.setJwt(jwt);
   }
   #makeAuthHeaders(option?: FetchPolicy): Record<string, string> {
     if (option?.token) return { Authorization: `Bearer ${option.token}` };

package/fetch/client/wsClient.ts

@@ -1,5 +1,6 @@
-import { Logger } from "akanjs/common";
+import { Logger, websocketAuthContract } from "akanjs/common";
 import type {
+  WebsocketAuthAck,
   WebsocketMessageData,
   WebsocketPublishData,
   WebsocketReqData,
@@ -39,6 +40,7 @@ export class WsClient {
   #roomSubscribeMap = new Map<string, SubscribeOption>();
   #listenerMap = new Map<string, Set<Listener>>();
   #destroyed = false;
+  #jwt: string | null = null;
   connected = false;
 
   constructor(
@@ -52,6 +54,21 @@ export class WsClient {
     this.ErrorCls = ErrorCls;
   }
 
+  /**
+   * The handshake only carries a same-origin cookie, so clients that hold the token in memory
+   * (native, cross-origin) authenticate with this frame instead. Signing out sends `null`, which
+   * drops the handshake cookie server-side and revokes the rooms it had authorized.
+   */
+  setJwt(jwt: string | null) {
+    if (this.#jwt === jwt) return;
+    this.#jwt = jwt;
+    if (this.#ws?.readyState === WebSocket.OPEN) this.#sendAuth();
+  }
+
+  #sendAuth() {
+    this.#ws?.send(JSON.stringify(websocketAuthContract.makeRequest(this.#jwt)));
+  }
+
   connect() {
     if (this.#ws && this.#ws.readyState !== WebSocket.CLOSED) return;
     this.logger.debug(`Connecting to ${this.url}`);
@@ -68,6 +85,8 @@ export class WsClient {
       this.#reconnectAttempts = 0;
       this.connected = true;
       this.logger.debug(`WebSocket connected`);
+
+      if (this.#jwt) this.#sendAuth();
       this.#roomSubscribeMap.forEach((option) => {
         const data: WebsocketReqData = { key: option.key, data: option.data, subscribe: true };
         this.#ws?.send(JSON.stringify(data));
@@ -97,6 +116,14 @@ export class WsClient {
             this.#handlePubsub(publishData.roomId, publishData.data);
             break;
           }
+          case "auth": {
+            const ack = parsed as WebsocketAuthAck;
+            for (const roomId of ack.revokedRooms) {
+              this.#roomSubscribeMap.delete(roomId);
+              this.logger.warn(`Websocket room ${roomId} is no longer authorized`);
+            }
+            break;
+          }
           default:
             this.logger.warn(`Unknown WebSocket message type: ${type} ${JSON.stringify(parsed)}`);
             break;

package/index.ts

@@ -163,6 +163,12 @@ export interface AppConfigResult {
   docker: DockerConfig;
   defaultDatabaseMode: DatabaseMode;
   routes?: AkanRouteConfig[];
+  /**
+   * Mounts `libs/<lib>/page` into this app under `page/(libs)/(<lib>)` on sync. `true` takes every lib
+   * dependency that ships a `page` folder, an array takes exactly the libs listed, `false` (the default)
+   * syncs nothing and removes what a previous sync created.
+   */
+  syncPageLibs?: string[] | boolean;
   externalLibs: string[];
   barrelImports: string[];
   optimizeImports: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.4.1",
+  "version": "2.4.2-rc.1",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanServer.ts

@@ -23,6 +23,7 @@ import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { WebProxyRunner } from "./proxy";
 import { SignalResolver } from "./resolver";
 import { ApiRouter } from "./routing/apiRouter";
+import type { AppWsData } from "./routing/appWsData";
 import type { HttpRoutes, SignalRoutes, WebsocketRoutes } from "./types";
 import type { WebRouter } from "./webRouter";
 
@@ -65,8 +66,8 @@ export interface AkanServerConsoleInfo {
 export class AkanServer {
   status: "stopped" | "initializing" | "initialized" | "starting" | "running" | "stopping" = "stopped";
 
-  #server: Bun.Server<{ createdAt: number } | HmrWsData> | null = null;
-  #wsServer: Bun.Server<{ createdAt: number } | HmrWsData> | null = null;
+  #server: Bun.Server<AppWsData | HmrWsData> | null = null;
+  #wsServer: Bun.Server<AppWsData | HmrWsData> | null = null;
   #prepared: AkanAppPrepared | null = null;
   readonly logger: Logger;
   readonly name: string;
@@ -241,7 +242,7 @@ export class AkanServer {
       }),
       
       data: {},
-    } as Bun.WebSocketHandler<{ createdAt: number } | HmrWsData>;
+    } as Bun.WebSocketHandler<AppWsData | HmrWsData>;
     
     this.#server = Bun.serve({
       idleTimeout: 0,
@@ -270,7 +271,7 @@ export class AkanServer {
           builtinRoutes,
           routeOptions,
           renderEnvRoutes,
-          upgradeAppWs: (req: Request, data: { createdAt: number }) => this.#wsServer?.upgrade(req, { data }) ?? false,
+          upgradeAppWs: (req: Request, data: AppWsData) => this.#wsServer?.upgrade(req, { data }) ?? false,
           webProxyRunner,
         }),
         websocket: websocketHandlers,

package/server/devtools/types.ts

@@ -8,7 +8,7 @@
  *   GET /_akan/deps        -> DevtoolsEnvelope<"deps",       DepsData>
  */
 
-import type { ConstantType } from "akanjs/constant";
+import type { ConstantType, TextFieldRole } from "akanjs/constant";
 import type { RootDictionary } from "akanjs/dictionary";
 import type { ArgType, SerializedArg, SerializedReturns } from "akanjs/signal";
 
@@ -73,7 +73,7 @@ export interface ConstantFieldNode {
   maxlength?: number;
   /** `ConstantFieldProps["type"]`: "email" | "password" | "url". */
   preset?: string;
-  text?: "search" | "filter";
+  text?: TextFieldRole;
   accumulate?: unknown;
   example?: unknown;
   meta?: Record<string, unknown>;

package/server/resolver/database.resolver.ts

@@ -49,11 +49,12 @@ const timedQuery = async <T>(fn: () => Promise<T>): Promise<T> => {
 export class DatabaseResolver {
   static resolveDatabase(constant: ConstantModel, database: DatabaseModel): AdaptorCls<DatabaseInstance> {
     const [modelName, className]: [string, string] = [database.refName, capitalize(database.refName)];
+
+    const resolveSort = (sortKey?: string | null) =>
+      sortKey ? (getFilterSortByKey(database.filter, sortKey) as { [key: string]: 1 | -1 }) : null;
     const getListQuery = (query?: QueryOf<any>, queryOption?: ListQueryOption) => {
       const find = query ?? {};
-      const sort = getFilterSortByKey(database.filter, queryOption?.sort ?? "latest") as {
-        [key: string]: 1 | -1;
-      };
+      const sort = resolveSort(queryOption?.sort);
       const skip = Number(queryOption?.skip ?? 0);
       const limit = queryOption?.limit === null ? DEFAULT_PAGE_SIZE : Number(queryOption?.limit ?? 0);
       const select = queryOption?.select;
@@ -62,9 +63,7 @@ export class DatabaseResolver {
     };
     const getFindQuery = (query?: QueryOf<any>, queryOption?: FindQueryOption) => {
       const find = query ?? {};
-      const sort = getFilterSortByKey(database.filter, queryOption?.sort ?? "latest") as {
-        [key: string]: 1 | -1;
-      };
+      const sort = resolveSort(queryOption?.sort);
       const skip = Number(queryOption?.skip ?? 0);
       const select = queryOption?.select;
       const sample = queryOption?.sample ?? false;

package/server/resolver/signal.resolver.ts

@@ -452,6 +452,29 @@ export class SignalResolver {
     return Boolean(req.headers.get("authorization") || req.headers.get("cookie")?.includes("jwt="));
   }
 
+  /**
+   * Re-checks the guards of every room this socket is subscribed to and drops the ones that no
+   * longer pass. Called when the socket's credential changes: a pubsub room is authorized once at
+   * subscribe time, so without this a signed-out socket would keep receiving its old rooms.
+   */
+  static async revalidateWsRooms(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry): Promise<string[]> {
+    const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
+    if (!roomCtxMap?.size) return [];
+    const websocket = SignalResolver.#getWebsocket(registry);
+    const revokedRooms: string[] = [];
+    for (const [roomId, roomCtx] of [...roomCtxMap]) {
+      if (await roomCtx.authorize()) continue;
+      ws.unsubscribe(roomId);
+      await Promise.all([...roomCtx.getWebSocketContext().onUnsubscribe.values()].map((handler) => handler()));
+      roomCtxMap.delete(roomId);
+      websocket.leaveRoom(ws, roomId);
+      revokedRooms.push(roomId);
+      SignalResolver.logger.verbose(`WebSocket lost access to room ${roomId}; unsubscribed`);
+    }
+    if (roomCtxMap.size === 0) SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
+    return revokedRooms;
+  }
+
   static async handleWsOpen(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry) {
     await SignalResolver.#getWebsocket(registry).registerSocket(ws);
   }