akanjs 3.0.0-alpha.2 → 3.0.0-alpha.21

package/server/resolver/database.resolver.ts

@@ -2,6 +2,7 @@ import type { PromiseOrObject } from "akanjs/base";
 import { applyMixins, capitalize } from "akanjs/common";
 import { type ConstantModel, DEFAULT_PAGE_SIZE, type QueryOf } from "akanjs/constant";
 import {
+  assertFilterFitsCrud,
   CacheDatabase,
   type CRUDEventType,
   type DatabaseInstance,
@@ -19,7 +20,9 @@ import {
   getLoaderInfos,
   type ListQueryOption,
   type Mdl,
+  NoDocumentError,
   type SaveEventType,
+  type UpdateChain,
 } from "akanjs/document";
 import {
   type AdaptorCls,
@@ -220,9 +223,9 @@ export class DatabaseResolver {
           refName: modelName,
           pickOne: (query: QueryOf<any>, projection?: any) => store.pickOne(query, { select: projection }),
           pickById: (id: string | undefined, projection?: any) => {
-            if (!id) throw new Error("No Document ID");
+            if (!id) throw new NoDocumentError("No Document ID");
             return store.findOne({ id }, { select: projection }).then((doc) => {
-              if (!doc) throw new Error(`No Document (${modelName}): ${id}`);
+              if (!doc) throw new NoDocumentError(`No Document (${modelName}): ${id}`);
               return doc;
             });
           },
@@ -232,11 +235,17 @@ export class DatabaseResolver {
           find: (query: QueryOf<any>) => createFindManyChain(query),
           findOne: (query: QueryOf<any>) => createFindOneChain(query),
           findById: (id: string | undefined) => (id ? store.findOne({ id }) : Promise.resolve(null)),
-          countDocuments: (query: QueryOf<any>) => store.count(query),
+          count: (query: QueryOf<any>) => store.count(query),
           updateOne: (query: QueryOf<any>, update: DocumentUpdateInput, options?: { upsert?: boolean }) =>
             store.updateOneByQuery(query, update, options),
           updateMany: (query: QueryOf<any>, update: DocumentUpdateInput) => store.updateManyByQuery(query, update),
+          removeOne: (query: QueryOf<any>) => store.removeOneByQuery(query),
           removeMany: (query: QueryOf<any>) => store.removeManyByQuery(query),
+          updateById: (id: string, update: DocumentUpdateInput, options?: { upsert?: boolean }) =>
+            store.updateOneByQuery({ id }, update, options),
+          removeById: (id: string) => store.removeOneByQuery({ id }),
+          
+          countDocuments: (query: QueryOf<any>) => store.count(query),
           bulkWrite: (
             operations: { updateOne: { filter: QueryOf<any>; update: DocumentUpdateInput; upsert?: boolean } }[],
           ) => store.bulkWrite(operations),
@@ -274,7 +283,7 @@ export class DatabaseResolver {
       async __pickId(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<string> {
         const { find, sort, skip, sample } = getFindQuery(query, queryOption);
         const id = await this.__store.findId(find, { sort, skip, sample });
-        if (!id) throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
+        if (!id) throw new NoDocumentError(`No Document (${database.refName}): ${JSON.stringify(query)}`);
         return id;
       }
       async __exists(query?: QueryOf<any>): Promise<string | null> {
@@ -300,7 +309,7 @@ export class DatabaseResolver {
       }
       async __get(id: string) {
         const doc = await this.__loader.load(id);
-        if (!doc) throw new Error(`No Document (${database.refName}): ${id}`);
+        if (!doc) throw new NoDocumentError(`No Document (${database.refName}): ${id}`);
         return doc;
       }
       async [`get${className}`](id: string) {
@@ -339,6 +348,15 @@ export class DatabaseResolver {
       async __removeMany(query: QueryOf<any>) {
         return await timedQuery(() => this.__store.removeManyByQuery(query));
       }
+      async __removeOne(query: QueryOf<any>) {
+        return await timedQuery(() => this.__store.removeOneByQuery(query));
+      }
+      async __updateMany(query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await timedQuery(() => this.__store.updateManyByQuery(query, update));
+      }
+      async __updateOne(query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await timedQuery(() => this.__store.updateOneByQuery(query, update));
+      }
       async [`remove${className}`](id: string) {
         return this.__remove(id);
       }
@@ -364,6 +382,7 @@ export class DatabaseResolver {
     Object.entries(filterMeta.query).forEach(([queryKey, filterInfo]) => {
       const queryFn = filterInfo.queryFn;
       if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
+      assertFilterFitsCrud(modelName, queryKey, className);
       Object.assign(DatabaseModelInstance.prototype, {
         [`list${capitalize(queryKey)}`]: async function (...args: any) {
           const { query, queryOption } = getQueryDataFromKey(queryKey, args);
@@ -403,6 +422,24 @@ export class DatabaseResolver {
         },
         [`query${capitalize(queryKey)}`]: (...args: any) =>
           queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper),
+        [`remove${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
+          return (this as unknown as DatabaseInstance).__removeMany(query);
+        },
+        [`removeOne${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
+          return (this as unknown as DatabaseInstance).__removeOne(query);
+        },
+        [`update${capitalize(queryKey)}`]: function (...args: any): UpdateChain {
+          const instance = this as unknown as DatabaseInstance;
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
+          return { set: (update) => instance.__updateMany(query, update) };
+        },
+        [`updateOne${capitalize(queryKey)}`]: function (...args: any): UpdateChain {
+          const instance = this as unknown as DatabaseInstance;
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
+          return { set: (update) => instance.__updateOne(query, update) };
+        },
       });
     });
     applyMixins(DatabaseModelInstance, [database.model]);

package/server/resolver/service.resolver.ts

@@ -2,10 +2,12 @@ import type { PromiseOrObject } from "akanjs/base";
 import { capitalize } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
 import {
+  assertFilterFitsCrud,
   type CRUDEventType,
   type DatabaseModel,
   type DataInputOf,
   type Doc,
+  type DocumentUpdateInput,
   documentQueryHelper,
   type FindQueryOption,
   fillMissingFilterArgs,
@@ -13,6 +15,7 @@ import {
   getFilterMeta,
   type ListQueryOption,
   type SaveEventType,
+  type UpdateChain,
 } from "akanjs/document";
 import type { DatabaseService, ServiceCls } from "akanjs/service";
 import type { CascadeRunner } from "./CascadeRunner";
@@ -108,6 +111,15 @@ export class ServiceResolver {
       async __removeMany(this: DatabaseService, query: QueryOf<any>) {
         return await this.__databaseModel.__removeMany(query);
       },
+      async __removeOne(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__removeOne(query);
+      },
+      async __updateMany(this: DatabaseService, query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await this.__databaseModel.__updateMany(query, update);
+      },
+      async __updateOne(this: DatabaseService, query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await this.__databaseModel.__updateOne(query, update);
+      },
     };
     return dbServiceMethods;
   }
@@ -138,6 +150,7 @@ export class ServiceResolver {
       const queryFn = filterInfo.queryFn;
       if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
       const capitalizedQueryKey = capitalize(queryKey);
+      assertFilterFitsCrud(database.refName, queryKey, className);
       Object.assign(srvRef.prototype, {
         [`list${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
           const { query, queryOption } = getQueryDataFromKey(queryKey, args);
@@ -178,6 +191,22 @@ export class ServiceResolver {
         [`query${capitalize(queryKey)}`]: function (this: DatabaseService, ...args: any) {
           return queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
         },
+        [`remove${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return this.__removeMany(query);
+        },
+        [`removeOne${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return this.__removeOne(query);
+        },
+        [`update${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any): UpdateChain {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return { set: (update) => this.__updateMany(query, update) };
+        },
+        [`updateOne${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any): UpdateChain {
+          const { query } = getQueryDataFromKey(queryKey, args);
+          return { set: (update) => this.__updateOne(query, update) };
+        },
       });
     });
     return srvRef;

package/server/resolver/signal.resolver.ts

@@ -362,6 +362,16 @@ export class SignalResolver {
             POST: normalHttpHandler,
           };
           break;
+        case "prompt":
+
+          if (!(endpointInfo.signalOption.guards ?? []).length)
+            SignalResolver.logger.warn(
+              `Prompt "${key}" declares no guards, and its GET route is mounted whether or not this app enables MCP.`,
+            );
+          routes[path] = {
+            GET: normalHttpHandler,
+          };
+          break;
         case "pubsub":
           wsRoutes[key] = async (ws, message, event) => {
             const websocket = SignalResolver.#getWebsocket(registry);
@@ -429,10 +439,15 @@ export class SignalResolver {
     return trimmed ? `/${trimmed}` : "";
   }
 
+  static #selectCache = new WeakMap<Cls, Record<string, true>>();
   static #selectForConstant(constant: Cls): Record<string, true> | undefined {
+    const cached = SignalResolver.#selectCache.get(constant);
+    if (cached) return cached;
     const fields = (constant as { [FIELD_META]?: Record<string, unknown> })[FIELD_META];
     if (!fields) return undefined;
-    return Object.fromEntries(Object.keys(fields).map((field) => [field, true]));
+    const select = Object.fromEntries(Object.keys(fields).map((field) => [field, true] as const));
+    SignalResolver.#selectCache.set(constant, select);
+    return select;
   }
 
   static #canUsePrimitiveQueryFastPath(endpointInfo: EndpointInfo, middleware: Map<string, MiddlewareCls>) {

package/server/routeTreeBuilder.ts

@@ -13,6 +13,7 @@ import type {
 import {
   assertUniqueRoutePatterns,
   compareRouteSpecificity,
+  getRouteExports,
   matchRoutePattern,
   parseBasePaths,
   parseRouteModuleKey,
@@ -49,44 +50,6 @@ export interface RouteModuleCacheStats {
 }
 
 export class RouteTreeBuilder {
-  static readonly #pageRouteExports = new Set([
-    "default",
-    "pageConfig",
-    "head",
-    "metadata",
-    "generateHead",
-    "generateMetadata",
-    "Loading",
-  ]);
-  static readonly #rootLayoutExports = new Set([
-    "default",
-    "pageConfig",
-    "head",
-    "metadata",
-    "generateHead",
-    "generateMetadata",
-    "fonts",
-    "manifest",
-    "theme",
-    "reconnect",
-    "wsConnect",
-    "layoutStyle",
-    "gaTrackingId",
-    "Loading",
-    "NotFound",
-    "Error",
-  ]);
-  static readonly #layoutRouteExports = new Set([
-    "default",
-    "pageConfig",
-    "head",
-    "metadata",
-    "generateHead",
-    "generateMetadata",
-    "Loading",
-    "NotFound",
-    "Error",
-  ]);
   static readonly #moduleCacheStats: RouteModuleCacheStats = {
     moduleCount: 0,
     loadedModuleCount: 0,
@@ -309,12 +272,7 @@ export class RouteTreeBuilder {
       return;
     }
     const parsed = parseRouteModuleKey(key);
-    const allowed =
-      kind === "page"
-        ? RouteTreeBuilder.#pageRouteExports
-        : parsed.isInternalRootLayout
-          ? RouteTreeBuilder.#rootLayoutExports
-          : RouteTreeBuilder.#layoutRouteExports;
+    const allowed = getRouteExports(kind, { rootLayout: parsed.isInternalRootLayout });
     for (const exportName of Object.keys(mod)) {
       if (!allowed.has(exportName)) {
         throw new Error(`[route-convention] unsupported export "${exportName}" in ${key}`);

package/server/rscWorker.tsx

@@ -13,6 +13,7 @@ import {
   getRequestFrameState,
   getRequestPolicy,
   getRequestTheme,
+  pushRequestFallback,
   requestStorage,
   setRequestFrameState,
   untrackedCookies,
@@ -1182,8 +1183,11 @@ export class RscRenderer {
   }
 
   #runWithRequest<T>(request: Request, fn: () => Promise<T>): Promise<T> {
-    if (requestStorage) return Promise.resolve(requestStorage.run(request, fn));
-    return fn();
+
+    const cleanup = pushRequestFallback(request);
+    const run = () => Promise.resolve(fn()).finally(() => cleanup());
+    if (requestStorage) return Promise.resolve(requestStorage.run(request, run));
+    return run();
   }
 
   async #renderFallbackDocument({

package/server/subRouteIndexDocument.tsx

@@ -0,0 +1,61 @@
+import type { ReactNode } from "react";
+import { SYSTEM_PAGE_STYLE } from "./systemPageDocument";
+
+export interface SubRouteIndexOptions {
+  locale: string;
+  basePaths: string[];
+  subRoutes?: Record<string, string[]>;
+}
+
+const SUB_ROUTE_INDEX_STYLE = `
+.akan-sub-route-list { margin: 26px 0 0; padding: 0; list-style: none; display: grid; gap: 10px; }
+.akan-sub-route-link { display: grid; gap: 4px; border: 1px solid rgba(255, 255, 255, 0.12); border-radius: 18px; background: rgba(26, 26, 26, 0.72); padding: 16px 18px; text-decoration: none; }
+.akan-sub-route-link:hover { border-color: var(--akan-primary); background: rgba(255, 73, 59, 0.08); }
+.akan-sub-route-name { color: var(--akan-foreground); font-size: 1.1rem; font-weight: 800; letter-spacing: -0.02em; }
+.akan-sub-route-path { color: rgba(255, 255, 255, 0.66); font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; font-size: 0.85rem; }
+.akan-sub-route-hosts { color: var(--akan-accent); font-size: 0.76rem; letter-spacing: 0.06em; overflow-wrap: anywhere; }
+`;
+
+export const getSubRouteIndexHref = (locale: string, basePath: string): string => `/${locale}/${basePath}`;
+
+export function createSubRouteIndexDocument({ locale, basePaths, subRoutes = {} }: SubRouteIndexOptions): ReactNode {
+  return (
+    <html lang={locale}>
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta name="robots" content="noindex" />
+        <title>Sub routes</title>
+        <style data-akan-system-page>{`${SYSTEM_PAGE_STYLE}${SUB_ROUTE_INDEX_STYLE}`}</style>
+      </head>
+      <body>
+        <main className="akan-system-page">
+          <section className="akan-system-card" aria-labelledby="akan-sub-route-title">
+            <p className="akan-system-eyebrow">Local dev</p>
+            <h1 id="akan-sub-route-title" className="akan-system-title">
+              Pick a sub route.
+            </h1>
+            <p className="akan-system-description">
+              This app serves every route under a sub path, so the site root has no page of its own. Only local runs see
+              this list; deployed hosts map straight onto one sub route.
+            </p>
+            <ul className="akan-sub-route-list">
+              {basePaths.map((basePath) => {
+                const hosts = subRoutes[basePath] ?? [];
+                return (
+                  <li key={basePath}>
+                    <a className="akan-sub-route-link" href={getSubRouteIndexHref(locale, basePath)}>
+                      <span className="akan-sub-route-name">{basePath}</span>
+                      <span className="akan-sub-route-path">{getSubRouteIndexHref(locale, basePath)}</span>
+                      {hosts.length ? <span className="akan-sub-route-hosts">{hosts.join(", ")}</span> : null}
+                    </a>
+                  </li>
+                );
+              })}
+            </ul>
+          </section>
+        </main>
+      </body>
+    </html>
+  );
+}

package/server/systemPageDocument.tsx

@@ -38,7 +38,7 @@ export const SYSTEM_PAGE_STATUS_COPY = {
   },
 } as const;
 
-const FALLBACK_STYLE = `
+export const SYSTEM_PAGE_STYLE = `
 :root { color-scheme: dark; --akan-primary: #ff493b; --akan-secondary: #2b2e33; --akan-accent: #d1a23b; --akan-foreground: #ffffff; --akan-background: #1a1a1a; --akan-base-200: #2a2a2a; --akan-error: #f02020; }
 body { margin: 0; min-height: 100vh; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: var(--akan-background); color: var(--akan-foreground); }
 a { color: inherit; }
@@ -70,7 +70,7 @@ export function createSystemPageDocument(options: SystemPageOptions): ReactNode
         {options.stylesheetHref ? (
           <link rel="stylesheet" href={options.stylesheetHref} precedence="default" data-akan-css="active" />
         ) : null}
-        <style data-akan-system-page>{FALLBACK_STYLE}</style>
+        <style data-akan-system-page>{SYSTEM_PAGE_STYLE}</style>
       </head>
       <body>
         <main className="akan-system-page min-h-screen bg-background text-foreground">

package/server/systemPages.tsx

@@ -1,3 +1,5 @@
+import type { ReactNode } from "react";
+import { createSubRouteIndexDocument, getSubRouteIndexHref, type SubRouteIndexOptions } from "./subRouteIndexDocument";
 import {
   createSystemPageDocument,
   SYSTEM_PAGE_STATUS_COPY,
@@ -9,26 +11,28 @@ export interface SystemPageResponseOptions extends SystemPageOptions {
   method?: string;
 }
 
+export interface SubRouteIndexResponseOptions extends SubRouteIndexOptions {
+  method?: string;
+}
+
 export { createSystemPageDocument, getSystemPageHomeHref } from "./systemPageDocument";
 
 export async function createSystemPageResponse(options: SystemPageResponseOptions): Promise<Response> {
-  const status = SYSTEM_PAGE_STATUS_COPY[options.kind].status;
-  const headers = createSystemPageHeaders();
-  if (options.method === "HEAD") return new Response(null, { status, headers });
+  return await renderDocumentResponse({
+    status: SYSTEM_PAGE_STATUS_COPY[options.kind].status,
+    method: options.method,
+    document: () => createSystemPageDocument(options),
+    fallbackText: () => createSystemPageFallbackText(options.kind),
+  });
+}
 
-  try {
-    const { renderToReadableStream } = await import("react-dom/server.browser");
-    const stream = await renderToReadableStream(createSystemPageDocument(options));
-    return new Response(stream, { status, headers });
-  } catch {
-    return new Response(createSystemPageFallbackText(options.kind), {
-      status,
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8",
-        "Cache-Control": "no-store",
-      },
-    });
-  }
+export async function createSubRouteIndexResponse(options: SubRouteIndexResponseOptions): Promise<Response> {
+  return await renderDocumentResponse({
+    status: 200,
+    method: options.method,
+    document: () => createSubRouteIndexDocument(options),
+    fallbackText: () => options.basePaths.map((basePath) => getSubRouteIndexHref(options.locale, basePath)).join("\n"),
+  });
 }
 
 export function createSystemPageHeaders(): Headers {
@@ -42,3 +46,32 @@ export function createSystemPageFallbackText(kind: SystemPageKind): string {
   const copy = SYSTEM_PAGE_STATUS_COPY[kind];
   return `${copy.status} ${copy.eyebrow}`;
 }
+
+async function renderDocumentResponse({
+  status,
+  method,
+  document,
+  fallbackText,
+}: {
+  status: number;
+  method?: string;
+  document: () => ReactNode;
+  fallbackText: () => string;
+}): Promise<Response> {
+  const headers = createSystemPageHeaders();
+  if (method === "HEAD") return new Response(null, { status, headers });
+
+  try {
+    const { renderToReadableStream } = await import("react-dom/server.browser");
+    const stream = await renderToReadableStream(document());
+    return new Response(stream, { status, headers });
+  } catch {
+    return new Response(fallbackText(), {
+      status,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+      },
+    });
+  }
+}

package/server/vendor/akanjs-fetch.ts

@@ -0,0 +1 @@
+export * from "akanjs/fetch";