akanjs 3.1.1 → 3.1.2-rc.0

package/document/filterMeta.ts

@@ -1,12 +1,12 @@
 import type { Cls, EnumInstance, MergeAllDoubleKeyOfObjects } from "akanjs/base";
-import { FILTER_DICT_SHAPE, FILTER_META, getNonArrayModel, isEnum } from "akanjs/base";
+import { Any, FILTER_DICT_SHAPE, FILTER_META, getNonArrayModel, isEnum, PrimitiveRegistry } from "akanjs/base";
 import {
   type BaseObject,
   type ConstantFieldType,
   type ConstantFieldTypeInput,
   type DocumentModel,
-  deserialize,
   type FieldToValue,
+  InputParser,
   type PlainTypeToFieldType,
   type QueryOf,
   type Serialized,
@@ -66,7 +66,8 @@ export const getFilterInfoByKey = <ArgNames extends string[] = [], Args extends
   modelRef: FilterCls,
   key: string,
 ): FilterInfo<ArgNames, Args, Model> => {
-  const queryMeta = getFilterMeta(modelRef).query[key];
+  const { query } = getFilterMeta(modelRef);
+  const queryMeta = Object.hasOwn(query, key) ? query[key] : undefined;
   if (!queryMeta) throw new Error(`queryMeta is not defined for key: ${key}`);
   return queryMeta;
 };
@@ -78,7 +79,10 @@ export const setFilterInfoByKey = <ArgNames extends string[] = [], Args extends
   const filterMeta = getFilterMeta(modelRef);
   Object.assign(filterMeta.query, { [key]: filterInfo });
 };
-export const getFilterSortByKey = (modelRef: FilterCls, key: string) => getFilterMeta(modelRef).sort[key];
+export const getFilterSortByKey = (modelRef: FilterCls, key: string) => {
+  const { sort } = getFilterMeta(modelRef);
+  return Object.hasOwn(sort, key) ? sort[key] : undefined;
+};
 
 export const fillMissingFilterArgs = (filterInfo: FilterInfo, args: unknown[]) => {
   if (args.length >= filterInfo.args.length) return args;
@@ -110,7 +114,10 @@ export interface FilterArgInfo {
   enum?: EnumInstance;
   nullable: boolean;
   ref?: string;
+  maxItems: number;
 }
+
+export const DEFAULT_FILTER_ARG_MAX_ITEMS = 1000;
 /** Unwraps a filter arg's declaration the way `EndpointInfo.getArgInfo` unwraps an endpoint's. */
 export const getFilterArgInfo = (arg: FilterInfo["args"][number]): FilterArgInfo => {
   const [singleArg, arrDepth] = getNonArrayModel(arg.argRef as Cls);
@@ -122,6 +129,7 @@ export const getFilterArgInfo = (arg: FilterInfo["args"][number]): FilterArgInfo
     enum: argIsEnum ? (singleArg as EnumInstance) : undefined,
     nullable: !!arg.option?.nullable,
     ref: arg.option?.ref,
+    maxItems: arg.option?.maxItems ?? DEFAULT_FILTER_ARG_MAX_ITEMS,
   };
 };
 export const getFilterArgInfos = (filterInfo: FilterInfo): FilterArgInfo[] => filterInfo.args.map(getFilterArgInfo);
@@ -129,9 +137,37 @@ export const getFilterArgInfos = (filterInfo: FilterInfo): FilterArgInfo[] => fi
 /** A caller named a filter that does not exist, or gave it arguments it cannot take. Its callers answer 400. */
 export class FilterQueryError extends Error {}
 
-const tryDeserializeFilterArg = (arg: FilterArgInfo, value: unknown, key: string) => {
+const countItems = (value: unknown, arrDepth: number): number =>
+  arrDepth && Array.isArray(value) ? value.reduce((sum: number, item) => sum + countItems(item, arrDepth - 1), 0) : 1;
+
+const isPlainContainer = (value: unknown) => {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return Array.isArray(value) || proto === Object.prototype || proto === null;
+};
+
+const primitiveShapeProblem = (value: unknown, arrDepth: number): string | null => {
+  if (!arrDepth) return isPlainContainer(value) ? "a single value" : null;
+  if (!Array.isArray(value)) return "a list";
+  for (const item of value) {
+    const problem = primitiveShapeProblem(item, arrDepth - 1);
+    if (problem) return problem;
+  }
+  return null;
+};
+
+const parseFilterArg = (arg: FilterArgInfo, value: unknown, key: string) => {
+  const shapeProblem = PrimitiveRegistry.has(arg.argRef as Cls) ? primitiveShapeProblem(value, arg.arrDepth) : null;
+  if (shapeProblem && value !== null && value !== undefined)
+    throw new FilterQueryError(`Invalid filter argument "${arg.name}" for key: ${key}: expected ${shapeProblem}`);
+  if (arg.arrDepth && countItems(value, arg.arrDepth) > arg.maxItems)
+    throw new FilterQueryError(`Filter argument "${arg.name}" for key: ${key} takes at most ${arg.maxItems} items`);
   try {
-    return deserialize(arg.argRef, arg.arrDepth, value, { key: arg.name, nullable: arg.nullable });
+    return InputParser.parse(arg.argRef as Cls, arg.arrDepth, value, {
+      key: arg.name,
+      nullable: arg.nullable,
+      enum: arg.enum,
+    });
   } catch (error) {
     throw new FilterQueryError(
       `Invalid filter argument "${arg.name}" for key: ${key}: ${error instanceof Error ? error.message : String(error)}`,
@@ -149,7 +185,8 @@ export const resolveFilterQuery = (
   args?: unknown[] | null,
 ): QueryOf<any> => {
   const key = queryKey || "any";
-  const filterInfo = getFilterMeta(filterRef).query[key];
+  const { query } = getFilterMeta(filterRef);
+  const filterInfo = Object.hasOwn(query, key) ? query[key] : undefined;
   const queryFn = filterInfo?.queryFn;
   if (!queryFn) throw new FilterQueryError(`No filter query for key: ${key}`);
   const given = Array.isArray(args) ? args : [];
@@ -157,7 +194,7 @@ export const resolveFilterQuery = (
     const value = given[idx];
     if (!arg.nullable && (value === null || value === undefined))
       throw new FilterQueryError(`Missing filter argument "${arg.name}" for key: ${key}`);
-    const parsed = tryDeserializeFilterArg(arg, value, key);
+    const parsed = parseFilterArg(arg, value, key);
 
     return parsed === null ? undefined : parsed;
   });
@@ -276,6 +313,7 @@ interface ArgProps<Value = unknown> {
   nullable?: boolean;
   ref?: string;
   default?: Value;
+  maxItems?: number;
 }
 export class FilterInfo<ArgNames extends string[] = any, Args extends any[] = any, Model = any> {
   readonly argNames: ArgNames = [] as unknown as ArgNames;
@@ -293,6 +331,7 @@ export class FilterInfo<ArgNames extends string[] = any, Args extends any[] = an
   >(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">) {
     if (this.queryFn) throw new Error("Query function is already set");
     else if (this.args.at(-1)?.option?.nullable) throw new Error("Last argument is nullable");
+    FilterInfo.#assertTyped(name, argRef);
     this.argNames.push(name);
     this.args.push({ name, argRef, option });
     return this as unknown as FilterInfo<[...ArgNames, ArgName], [...Args, arg: _FieldToValue], Model>;
@@ -304,6 +343,7 @@ export class FilterInfo<ArgNames extends string[] = any, Args extends any[] = an
     _FieldToValue = DocumentModel<FieldToValue<Arg>>,
   >(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">) {
     if (this.queryFn) throw new Error("Query function is already set");
+    FilterInfo.#assertTyped(name, argRef);
     this.argNames.push(name);
     this.args.push({ name, argRef, option: { ...option, nullable: true } });
     return this as unknown as FilterInfo<[...ArgNames, ArgName], [...Args, opt?: _FieldToValue | null], Model>;
@@ -313,6 +353,14 @@ export class FilterInfo<ArgNames extends string[] = any, Args extends any[] = an
     this.queryFn = query;
     return this;
   }
+  
+  static #assertTyped(name: string, argRef: ConstantFieldTypeInput) {
+    const [single] = getNonArrayModel(argRef as Cls);
+    if (single === Any)
+      throw new Error(
+        `Filter argument "${name}" is declared as Any; declare its type (a primitive, an enum or a scalar) so a caller's value is checked against it`,
+      );
+  }
 }
 
 export const filter = () => new FilterInfo<[], [], any>();

package/document/queryEvaluator.ts

@@ -4,7 +4,9 @@ import {
   type DocumentQueryNode,
   type DocumentQueryOperator,
   encodeDocumentValue,
+  fieldValueProblem,
   isDocumentQueryNode,
+  queryNodeProblem,
   queryOperatorKeys,
   sanitizeJson,
 } from "./documentQuery";
@@ -51,6 +53,8 @@ export class DocumentQueryEvaluator {
   static unevaluableReason(query: DocumentQuery | undefined): string | null {
     if (!query || typeof query !== "object") return null;
     if (isDocumentQueryNode(query)) {
+      const problem = queryNodeProblem(query);
+      if (problem) return problem;
       if (query.kind === "raw") return "q.raw() carries SQL that only the database can run";
       if (query.kind === "search") return "q.search() compiles to a full-text JOIN with no in-memory equivalent";
       if (query.kind === "all" || query.kind === "any")
@@ -69,12 +73,12 @@ export class DocumentQueryEvaluator {
 
   static #unevaluableField(path: string, value: unknown): string | null {
     if (!value || typeof value !== "object") return null;
+    const problem = fieldValueProblem(path, value);
+    if (problem) return problem;
     if (baseDocumentColumns.has(path)) return null;
     const keyAbsence = `${path}: exists/missing asks whether the key is in the stored JSON, which a document in hand cannot answer — use q.empty()`;
-    if (isDocumentQueryNode(value)) {
-      if (value.kind === "op") return value.op === "exists" || value.op === "missing" ? keyAbsence : null;
-      return DocumentQueryEvaluator.unevaluableReason(value as DocumentQuery);
-    }
+    if (isDocumentQueryNode(value))
+      return value.kind === "op" && (value.op === "exists" || value.op === "missing") ? keyAbsence : null;
     const operators = value as Record<string, unknown>;
     
     if ("exists" in operators || "missing" in operators || ("empty" in operators && !operators.empty))
@@ -102,6 +106,8 @@ export class DocumentQueryEvaluator {
   }
 
   #node(node: DocumentQueryNode, row: DocumentRowView): boolean {
+    const problem = queryNodeProblem(node);
+    if (problem) throw new Error(problem);
     switch (node.kind) {
       
       case "all":
@@ -119,10 +125,9 @@ export class DocumentQueryEvaluator {
   }
 
   #field(path: string, value: unknown, row: DocumentRowView): boolean {
-    if (isDocumentQueryNode(value)) {
-      if (value.kind !== "op") return this.evaluate({ [path]: value } as DocumentQuery, row);
-      return this.#operator(path, value.op, value.value, row);
-    }
+    const problem = fieldValueProblem(path, value);
+    if (problem) throw new Error(problem);
+    if (isDocumentQueryNode(value) && value.kind === "op") return this.#operator(path, value.op, value.value, row);
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const operators = value as Record<string, unknown>;
       const keys = Object.keys(operators);

package/fetch/client/fetchClient.ts

@@ -1,12 +1,14 @@
 import { getApiPrefix, getEnv, getWsPrefix, PrimitiveRegistry, type PromiseOrObject } from "akanjs/base";
 import {
-  capitalize,
+  endpointNames,
   type FetchPolicy,
   fileUploadContract,
   Logger,
+  modelNames,
   type RetryPolicy,
   readSessionToken,
   resolveFileUploadCapability,
+  sliceNames,
   trimTrailingSlashes,
 } from "akanjs/common";
 import { type BaseInsight, type BaseObject, ConstantRegistry, deserialize, serialize } from "akanjs/constant";
@@ -377,7 +379,7 @@ export class FetchClient {
     Object.entries(this.handler).forEach(([key, handler]) => {
       if (!(key in instance.handler)) instance.handler[key] = handler;
     });
-    instance.setJwt(jwt ?? this.jwt);
+    instance.setJwt(jwt ?? (FetchClient.#sameOrigin(instance.origin, this.origin) ? this.jwt : null));
     if (connect) instance.connect();
     return FetchClient.#makeProxy(instance);
   }
@@ -390,7 +392,6 @@ export class FetchClient {
   setJwt(jwt: string | null) {
     this.jwt = jwt;
     this.ws.setJwt(jwt);
-    for (const ws of this.#originWs.values()) ws.setJwt(jwt);
   }
   
   #resolveWs(origin?: string) {
@@ -400,7 +401,6 @@ export class FetchClient {
     if (cached) return cached;
     const ws = new WsClient(FetchClient.#makeWsUri(target), this.ErrorCls).configure(this.#wsOptions);
     this.#originWs.set(target, ws);
-    ws.setJwt(this.jwt);
     ws.connect();
     return ws;
   }
@@ -425,9 +425,12 @@ export class FetchClient {
   static #sameOrigin(a: string, b: string) {
     return FetchClient.#normalizeOrigin(a) === FetchClient.#normalizeOrigin(b);
   }
+  #ownOrigin(option?: FetchPolicy) {
+    return !option?.origin || FetchClient.#sameOrigin(option.origin, this.origin);
+  }
 
   #forwardsVisitor(option?: FetchPolicy) {
-    return !this.#foreign && (!option?.origin || FetchClient.#sameOrigin(option.origin, this.origin));
+    return !this.#foreign && this.#ownOrigin(option);
   }
   #makeAuthHeaders(option?: FetchPolicy): Record<string, string> {
     if (option?.token) return { Authorization: `Bearer ${option.token}` };
@@ -441,7 +444,7 @@ export class FetchClient {
       }
     } catch {
     }
-    return this.jwt ? { Authorization: `Bearer ${this.jwt}` } : {};
+    return this.jwt && this.#ownOrigin(option) ? { Authorization: `Bearer ${this.jwt}` } : {};
   }
   #baseUrlOf(endpoint: SerializedEndpoint, origin?: string) {
     if (endpoint.globalPrefix !== false) return origin;
@@ -519,7 +522,7 @@ export class FetchClient {
         this.#setHandlerFactory(key, () => this.#makeHttpFn(key, endpoint, prefix));
         return;
       case "pubsub": {
-        this.#setHandlerFactory(`subscribe${capitalize(key)}`, () => {
+        this.#setHandlerFactory(endpointNames(key).subscribe, () => {
           const roomArgs = endpoint.args.filter((arg) => arg.type === "room");
           const roomArgLength = roomArgs.length;
           const serializerMap = this.#makeArgSerializer(endpoint.args);
@@ -567,7 +570,7 @@ export class FetchClient {
             this.#resolveWs(fetchPolicy?.origin).emit(key, data);
           };
         });
-        this.#setHandlerFactory(`listen${capitalize(key)}`, () => {
+        this.#setHandlerFactory(endpointNames(key).listen, () => {
           const parseReturn = this.#makeReturnParser(endpoint.returns);
           const wrappedListeners = new WeakMap<(data: unknown) => void, (data: unknown) => void>();
           return ((handleEvent: (data: unknown) => void, fetchPolicy: FetchPolicy = {}) => {
@@ -654,15 +657,7 @@ export class FetchClient {
   }
 
   static getBaseEndpoint(refName: string, signal: SerializedSignal) {
-    const capRefName = capitalize(refName);
-    const names = {
-      createModel: `create${capRefName}`,
-      updateModel: `update${capRefName}`,
-      removeModel: `remove${capRefName}`,
-      model: refName,
-      modelId: `${refName}Id`,
-      lightModel: `light${capRefName}`,
-    };
+    const names = modelNames(refName);
     const createGuards = FetchClient.#mountedGuards(signal, "create");
     const updateGuards = FetchClient.#mountedGuards(signal, "update");
     const removeGuards = FetchClient.#mountedGuards(signal, "remove");
@@ -725,22 +720,6 @@ export class FetchClient {
     const guards = verb === "get" ? signal.getGuards : (signal[`${verb}Guards`] ?? signal.cruGuards);
     return guards?.some((guard) => guard !== "None") ? guards : undefined;
   }
-  static #modelNames(refName: string) {
-    const capRefName = capitalize(refName);
-    return {
-      createModel: `create${capRefName}`,
-      updateModel: `update${capRefName}`,
-      removeModel: `remove${capRefName}`,
-      model: refName,
-      lightModel: `light${capRefName}`,
-      viewModel: `view${capRefName}`,
-      getModelView: `get${capRefName}View`,
-      editModel: `edit${capRefName}`,
-      getModelEdit: `get${capRefName}Edit`,
-      addModelFiles: `add${capRefName}Files`,
-      mergeModel: `merge${capRefName}`,
-    };
-  }
   
   static #helpersOf(signal: SerializedSignal) {
     const get = !!FetchClient.#mountedGuards(signal, "get");
@@ -749,24 +728,13 @@ export class FetchClient {
       update || !!FetchClient.#mountedGuards(signal, "create") || !!FetchClient.#mountedGuards(signal, "remove");
     return { view: get, edit: get && write, merge: update };
   }
-  static #sliceNames(refName: string, suffix: string) {
-    const capSuffix = capitalize(suffix);
-    const capRefName = capitalize(refName);
-    return {
-      list: `${refName}List${capSuffix}`,
-      insight: `${refName}Insight${capSuffix}`,
-      live: `${refName}Live${capSuffix}`,
-      init: `init${capRefName}${capSuffix}`,
-      getInit: `get${capRefName}Init${capSuffix}`,
-    };
-  }
   /** The `fetch.*` names a module's signal registers, and the bare socket route of each pubsub and message. */
   static claimsOf(refName: string, signal: SerializedSignal) {
     const handlers: FetchClaim[] = [];
     const sockets: FetchClaim[] = [];
     const claim = (key: string, endpoint: SerializedEndpoint, by: string) => {
-      handlers.push({ key: endpoint.type === "pubsub" ? `subscribe${capitalize(key)}` : key, by });
-      if (endpoint.type === "message") handlers.push({ key: `listen${capitalize(key)}`, by });
+      handlers.push({ key: endpoint.type === "pubsub" ? endpointNames(key).subscribe : key, by });
+      if (endpoint.type === "message") handlers.push({ key: endpointNames(key).listen, by });
       if (endpoint.type === "pubsub" || endpoint.type === "message") sockets.push({ key, by });
     };
     for (const [key, endpoint] of Object.entries(signal.endpoint))
@@ -775,7 +743,7 @@ export class FetchClient {
     const generated = "the generated CRUD";
     for (const [key, endpoint] of Object.entries(FetchClient.getBaseEndpoint(refName, signal)))
       claim(key, endpoint, generated);
-    const names = FetchClient.#modelNames(refName);
+    const names = modelNames(refName);
     const helpers = FetchClient.#helpersOf(signal);
     const helperKeys = [
       ...(helpers.view ? [names.viewModel, names.getModelView] : []),
@@ -788,13 +756,13 @@ export class FetchClient {
       const by = suffix ? `the slice "${suffix}"` : "the root slice";
       for (const [key, endpoint] of Object.entries(FetchClient.getEndpointFromSlice(refName, suffix, slice)))
         claim(key, endpoint, by);
-      const { init, getInit } = FetchClient.#sliceNames(refName, suffix);
+      const { init, getInit } = sliceNames(refName, suffix).endpoint;
       handlers.push({ key: init, by }, { key: getInit, by });
     }
     return { handlers, sockets };
   }
   #registerModelBaseEndpoint(refName: string, signal: SerializedSignal) {
-    const names = FetchClient.#modelNames(refName);
+    const names = modelNames(refName);
     
     for (const key of Object.values(names).filter((key) => this.#generatedBy.get(key) === refName)) {
       this.#handlerFactory.delete(key);
@@ -810,7 +778,7 @@ export class FetchClient {
     if (helpers.view) {
       this.#setHandlerFactory(
         names.viewModel,
-        () => this.#makeModelHandleFn(refName, names.model, names.viewModel, `${refName}View`),
+        () => this.#makeModelHandleFn(refName, names.model, names.viewModel, names.modelView),
         refName,
       );
       this.#setHandlerFactory(names.getModelView, () => this.#makeModelObjFn(refName, names.getModelView), refName);
@@ -818,7 +786,7 @@ export class FetchClient {
     if (helpers.edit) {
       this.#setHandlerFactory(
         names.editModel,
-        () => this.#makeModelHandleFn(refName, names.model, names.editModel, `${refName}Edit`),
+        () => this.#makeModelHandleFn(refName, names.model, names.editModel, names.modelEdit),
         refName,
       );
       this.#setHandlerFactory(names.getModelEdit, () => this.#makeModelObjFn(refName, names.getModelEdit), refName);
@@ -867,13 +835,15 @@ export class FetchClient {
   }
 
   #makeModelObjFn(refName: string, callerKey: string) {
+    const names = modelNames(refName);
     return (async (id: string, option?: FetchPolicy) => {
       const modelObj = await this.#requireHandler(refName, callerKey)(id, { ...option, crystalize: false });
-      return { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() };
+      return { refName, [names.modelObj]: modelObj, [names.modelViewAt]: new Date() };
     }) as FetchHandler;
   }
 
   #makeModelHandleFn(refName: string, modelKey: string, callerKey: string, payloadKey: string) {
+    const names = modelNames(refName);
     return ((id: string, option?: FetchPolicy) => {
       const cnst = ConstantRegistry.getDatabase(refName);
       const modelFn = this.#requireHandler(modelKey, callerKey);
@@ -882,7 +852,7 @@ export class FetchClient {
       let payload: object | undefined;
       const modelOf = (modelObj: object) => (model ??= new cnst.full(modelObj));
       const payloadOf = (modelObj: object) =>
-        (payload ??= { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() });
+        (payload ??= { refName, [names.modelObj]: modelObj, [names.modelViewAt]: new Date() });
       return FetchHandle.of<Record<string, unknown>, Record<string, Promise<unknown>>>(
         [modelRequest],
         async () => {
@@ -902,7 +872,7 @@ export class FetchClient {
     suffix: string,
     slice: SerializedSlice,
   ): { [key: string]: SerializedEndpoint } {
-    const names = FetchClient.#sliceNames(refName, suffix);
+    const names = sliceNames(refName, suffix).endpoint;
     
     const mcp = {
       ...(slice.mcp === false ? { mcp: false as const } : {}),
@@ -936,10 +906,7 @@ export class FetchClient {
     return endpoint;
   }
   #registerSlice(refName: string, suffix: string, slice: SerializedSlice, prefix?: string) {
-    const capSuffix = capitalize(suffix);
-    const sliceName = `${refName}${capSuffix}`;
-    const capRefName = capitalize(refName);
-    const names = FetchClient.#sliceNames(refName, suffix);
+    const { slice: sliceName, endpoint: names } = sliceNames(refName, suffix);
 
     const endpoint = FetchClient.getEndpointFromSlice(refName, suffix, slice);
     
@@ -971,8 +938,7 @@ export class FetchClient {
       ) as Promise<BaseInsight | null>;
       return new SliceInitHandle({
         refName,
-        capRefName,
-        capSuffix,
+        suffix,
         sliceName,
         argLength,
         queryArgs,
@@ -990,7 +956,7 @@ export class FetchClient {
         names.init,
         names.getInit,
       );
-      return await initFn(...args)[`${refName}Init${capSuffix}`];
+      return await initFn(...args)[names.initResult];
     });
   }
   #makeArgSerializer(args: SerializedArg[]) {
@@ -1117,7 +1083,7 @@ export class FetchClient {
       const cnst = ConstantRegistry.getDatabase(refName, { allowEmpty: true });
       if (!cnst) return;
       const slices = Object.entries(serializedSignal.slice).map(([suffix, serializedSlice]) => {
-        const sliceName = `${refName}${capitalize(suffix)}`;
+        const { slice: sliceName } = sliceNames(refName, suffix);
         proxy.slice[sliceName] = { refName, sliceName, argLength: serializedSlice.args.length };
         return { refName, sliceName, serializedSlice };
       });

package/fetch/client/httpClient.ts

@@ -25,6 +25,7 @@ const jsonContentType = /^application\/(?:[\w.+-]+\+)?json\b/i;
 
 const transportErrorKeyMap = {
   408: "base.error.gatewayTimeout",
+  413: "base.error.payloadTooLarge",
   429: "base.error.tooManyRequests",
   502: "base.error.serverUnavailable",
   503: "base.error.serverUnavailable",

package/fetch/client/sliceInitHandle.ts

@@ -1,12 +1,12 @@
 import { DataList } from "akanjs/base";
+import { modelNames, sliceNames } from "akanjs/common";
 import { type BaseInsight, type BaseObject, withSharedInstances } from "akanjs/constant";
 
 import { FetchHandle } from "./fetchHandle";
 
 export interface SliceInitInput {
   refName: string;
-  capRefName: string;
-  capSuffix: string;
+  suffix: string;
   sliceName: string;
   argLength: number;
   queryArgs: unknown[];
@@ -35,12 +35,9 @@ export class SliceInitHandle {
   }
 
   build() {
-    const { refName, capSuffix, listRequest, insightRequest } = this.#input;
-    const keys = {
-      init: `${refName}Init${capSuffix}`,
-      list: `${refName}List${capSuffix}`,
-      insight: `${refName}Insight${capSuffix}`,
-    };
+    const { refName, suffix, listRequest, insightRequest } = this.#input;
+    const { initResult, list, insight } = sliceNames(refName, suffix).endpoint;
+    const keys = { init: initResult, list, insight };
     return FetchHandle.of<Record<string, unknown>, Record<string, Promise<unknown>>>(
       [listRequest, insightRequest],
       async () => {
@@ -62,23 +59,26 @@ export class SliceInitHandle {
   }
 
   #serverInitOf(modelObjList: BaseObject[], modelObjInsight: BaseInsight | null) {
-    const { refName, capRefName, sliceName, argLength, queryArgs, page, limit, sort } = this.#input;
+    const { refName, sliceName, argLength, queryArgs, page, limit, sort } = this.#input;
+    const { modelObjList: modelObjListKey, modelObjInsight: modelObjInsightKey } = modelNames(refName);
+    const { pageOfModel, lastPageOfModel, limitOfModel, hasMoreOfModel, queryArgsOfModel, sortOfModel, modelInitAt } =
+      sliceNames(refName).state;
     const lastPage =
       modelObjInsight?.count && limit > 0 ? Math.max(Math.floor((modelObjInsight.count - 1) / limit) + 1, 1) : 1;
     this.#serverInit ??= {
       refName,
       sliceName,
       argLength,
-      [`${refName}ObjList`]: modelObjList,
-      [`${refName}ObjInsight`]: modelObjInsight,
-      [`pageOf${capRefName}`]: page,
-      [`lastPageOf${capRefName}`]: lastPage,
-      [`limitOf${capRefName}`]: limit,
+      [modelObjListKey]: modelObjList,
+      [modelObjInsightKey]: modelObjInsight,
+      [pageOfModel]: page,
+      [lastPageOfModel]: lastPage,
+      [limitOfModel]: limit,
       
-      [`hasMoreOf${capRefName}`]: !!limit && modelObjList.length >= limit,
-      [`queryArgsOf${capRefName}`]: queryArgs,
-      [`sortOf${capRefName}`]: sort,
-      [`${refName}InitAt`]: new Date(),
+      [hasMoreOfModel]: !!limit && modelObjList.length >= limit,
+      [queryArgsOfModel]: queryArgs,
+      [sortOfModel]: sort,
+      [modelInitAt]: new Date(),
     };
     return this.#serverInit;
   }

package/fetch/index.ts

@@ -4,4 +4,5 @@ export * from "./client";
 export * from "./fetchType";
 export * from "./renderScope";
 export * from "./requestStorage";
+export * from "./sessionCookie";
 export * from "./types";

package/fetch/sessionCookie.ts

@@ -0,0 +1,37 @@
+import { getEnv } from "akanjs/base";
+import { authTokenKey } from "akanjs/common";
+
+interface SessionCookieIssueOption {
+  /** Seconds the pair is kept; left out, both are session cookies. */
+  maxAge?: number;
+}
+
+export class SessionCookie {
+  static claimsKey(): string {
+    return `${authTokenKey()}.claims`;
+  }
+
+  static claimsOf(jwt: string): string {
+    const [header = "", payload = ""] = jwt.split(".");
+    return `${header}.${payload}`;
+  }
+
+  static issue(jwt: string, { maxAge }: SessionCookieIssueOption = {}): string[] {
+    const age = maxAge === undefined ? "" : `; Max-Age=${maxAge}`;
+    return [
+      `${authTokenKey()}=${encodeURIComponent(jwt)}; ${SessionCookie.#attrs()}; HttpOnly${age}`,
+      `${SessionCookie.claimsKey()}=${encodeURIComponent(SessionCookie.claimsOf(jwt))}; ${SessionCookie.#attrs()}${age}`,
+    ];
+  }
+
+  static expire(): string[] {
+    return [
+      `${authTokenKey()}=; ${SessionCookie.#attrs()}; HttpOnly; Max-Age=0`,
+      `${SessionCookie.claimsKey()}=; ${SessionCookie.#attrs()}; Max-Age=0`,
+    ];
+  }
+
+  static #attrs() {
+    return `Path=/; SameSite=Lax${getEnv().operationMode === "local" ? "" : "; Secure"}`;
+  }
+}

package/index.ts

@@ -163,6 +163,10 @@ export interface AkanNativeUpdatesConfig {
    * phone always takes a new web bundle by itself. Default true.
    */
   automatic?: boolean;
+  /** Windows: SHA-1 thumbprints a release must be Authenticode-signed by, in place of the installed app's signer. */
+  windowsSigners?: string[];
+  /** Seconds a published manifest stays valid, at least 3600; left out, manifests never expire. */
+  expiresIn?: number;
 }
 
 export interface AkanNativeIosConfig {
@@ -328,6 +332,10 @@ export interface AkanNativeSettings {
    * internal test target only, since anyone holding the device can then read and drive the page.
    */
   devtools?: boolean;
+  /** Directives extend the default policy, a string replaces it (`"strict"` is the native preset), false ships none. */
+  csp?: false | string | Record<string, string | string[]>;
+  /** The URL patterns `opener` may open. Default https, `mailto:` and `tel:` links; `["*"]` lifts the limit. */
+  openUrls?: string[];
   ios?: AkanNativeIosConfig;
   android?: AkanNativeAndroidConfig;
   desktop?: AkanNativeDesktopConfig;