@zenithbuild/cli 0.7.10 → 0.7.12

package/dist/server-runtime/route-render.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { attachRouteAuth } from '../auth/route-auth.js';
 import { appLocalRedirectLocation, normalizeBasePath, prependBasePath } from '../base-path.js';
@@ -6,9 +7,27 @@ import { createImageRuntimePayload, injectImageRuntimePayload } from '../images/
 import { materializeImageMarkup } from '../images/materialize.js';
 import { buildResourceResponseDescriptor } from '../resource-response.js';
 import { clientFacingRouteMessage, defaultRouteDenyMessage, logServerException } from '../server-error.js';
-import { allow, data, deny, download, invalid, json, redirect, resolveRouteResult, text } from '../server-contract.js';
+import { allow, data, deny, download, invalid, json, redirect, text } from '../server-contract.js';
+import { executeMatchedRoutePipeline } from '../server-contract/resolve.js';
 const MODULE_CACHE = new Map();
+const GLOBAL_MIDDLEWARE_MODULE_CACHE = new Map();
 const INTERNAL_QUERY_PREFIX = '__zenith_param_';
+const SCOPED_ROUTE_FIELD = ['scoped', 'server', 'data'].join('_');
+const HAS_SCOPED_ROUTE_FIELD = ['has', SCOPED_ROUTE_FIELD].join('_');
+let SCOPED_SERVER_DATA_RUNTIME_PROMISE = null;
+function hasRouteScopedServerData(route) {
+    return route?.route_kind !== 'resource' &&
+        route?.prerender !== true &&
+        route?.[HAS_SCOPED_ROUTE_FIELD] === true &&
+        Array.isArray(route?.[SCOPED_ROUTE_FIELD]) &&
+        route[SCOPED_ROUTE_FIELD].length > 0;
+}
+async function loadScopedServerDataRuntime() {
+    if (!SCOPED_SERVER_DATA_RUNTIME_PROMISE) {
+        SCOPED_SERVER_DATA_RUNTIME_PROMISE = import('../scoped-server-data/runtime.js');
+    }
+    return SCOPED_SERVER_DATA_RUNTIME_PROMISE;
+}
 function parseCookies(rawCookieHeader) {
     const out = Object.create(null);
     const raw = String(rawCookieHeader || '');
@@ -159,6 +178,22 @@ async function loadRouteExports(routeModulePath) {
     MODULE_CACHE.set(cacheKey, value);
     return value;
 }
+async function loadGlobalMiddleware(globalMiddlewareModulePath) {
+    if (!globalMiddlewareModulePath) {
+        return null;
+    }
+    const cacheKey = globalMiddlewareModulePath;
+    if (GLOBAL_MIDDLEWARE_MODULE_CACHE.has(cacheKey)) {
+        return GLOBAL_MIDDLEWARE_MODULE_CACHE.get(cacheKey);
+    }
+    const mod = await import(pathToFileURL(globalMiddlewareModulePath).href);
+    const middlewareFn = mod?.default;
+    if (typeof middlewareFn !== 'function') {
+        throw new Error('[Zenith:Middleware] Compiled global middleware module must default export a function.');
+    }
+    GLOBAL_MIDDLEWARE_MODULE_CACHE.set(cacheKey, middlewareFn);
+    return middlewareFn;
+}
 function createRouteContext({ request, route, params, publicUrl, guardOnly = false }) {
     const requestHeaders = Object.fromEntries(request.headers.entries());
     const ctx = {
@@ -198,24 +233,28 @@ function createRouteContext({ request, route, params, publicUrl, guardOnly = fal
  *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null },
  *   params: Record<string, string>,
  *   routeModulePath: string,
+ *   globalMiddlewareModulePath?: string | null,
  *   guardOnly?: boolean
  * }} options
- * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
+ * @returns {Promise<{ publicUrl: URL, ctx: object, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
 export async function executeRouteRequest(options) {
-    const { request, route, params, routeModulePath, guardOnly = false } = options;
+    const { request, route, params, routeModulePath, globalMiddlewareModulePath = null, guardOnly = false } = options;
     const publicUrl = buildPublicUrl(request.url, route, params);
     const ctx = createRouteContext({ request, route, params, publicUrl, guardOnly });
     const exports = await loadRouteExports(routeModulePath);
-    const resolved = await resolveRouteResult({
+    const globalMiddleware = await loadGlobalMiddleware(globalMiddlewareModulePath);
+    const resolved = await executeMatchedRoutePipeline({
         exports,
         ctx,
         filePath: route.file || route.server_script_path || route.path,
         guardOnly,
-        routeKind: route.route_kind === 'resource' ? 'resource' : 'page'
+        routeKind: route.route_kind === 'resource' ? 'resource' : 'page',
+        globalMiddleware
     });
     return {
         publicUrl,
+        ctx,
         result: resolved.result,
         trace: resolved.trace,
         status: resolved.status,
@@ -228,20 +267,23 @@ export async function executeRouteRequest(options) {
  *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null },
  *   params: Record<string, string>,
  *   routeModulePath: string,
+ *   globalMiddlewareModulePath?: string | null,
  *   shellHtmlPath: string,
  *   imageManifestPath?: string | null,
- *   imageConfig?: Record<string, unknown>
+ *   imageConfig?: Record<string, unknown>,
+ *   scopedModuleBaseDir?: string | null
  * }} options
  * @returns {Promise<Response>}
  */
 export async function renderRouteRequest(options) {
-    const { request, route, params, routeModulePath, shellHtmlPath, imageManifestPath = null, imageConfig = {} } = options;
+    const { request, route, params, routeModulePath, globalMiddlewareModulePath = null, shellHtmlPath, imageManifestPath = null, imageConfig = {}, scopedModuleBaseDir = null } = options;
     try {
-        const { publicUrl, result, status, setCookies = [] } = await executeRouteRequest({
+        const { ctx, result, status, setCookies = [] } = await executeRouteRequest({
             request,
             route,
             params,
-            routeModulePath
+            routeModulePath,
+            globalMiddlewareModulePath
         });
         if (result.kind === 'redirect') {
             const headers = new Headers({
@@ -261,6 +303,16 @@ export async function renderRouteRequest(options) {
         const ssrPayload = result.kind === 'data' && result.data && typeof result.data === 'object' && !Array.isArray(result.data)
             ? result.data
             : {};
+        let finalSsrPayload = ssrPayload;
+        if (hasRouteScopedServerData(route)) {
+            const scopedRuntime = await loadScopedServerDataRuntime();
+            const scopedPayload = await scopedRuntime.executeScopedServerData({
+                route,
+                ctx,
+                serverDir: scopedModuleBaseDir || dirname(dirname(dirname(dirname(routeModulePath))))
+            });
+            finalSsrPayload = scopedRuntime.mergeScopedSsrPayload(ssrPayload, scopedPayload);
+        }
         const localImages = await loadImageManifest(imageManifestPath);
         const imagePayload = createImageRuntimePayload(imageConfig, localImages, 'passthrough', route.base_path || '/');
         let html = await readFile(shellHtmlPath, 'utf8');
@@ -271,7 +323,7 @@ export async function renderRouteRequest(options) {
                 ? route.image_materialization
                 : []
         });
-        html = injectSsrPayload(html, ssrPayload);
+        html = injectSsrPayload(html, finalSsrPayload);
         html = injectImageRuntimePayload(html, imagePayload);
         const headers = new Headers({
             'Content-Type': 'text/html; charset=utf-8'
@@ -292,18 +344,20 @@ export async function renderRouteRequest(options) {
  *   request: Request,
  *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null, route_kind?: string | null, base_path?: string | null },
  *   params: Record<string, string>,
- *   routeModulePath: string
+ *   routeModulePath: string,
+ *   globalMiddlewareModulePath?: string | null
  * }} options
  * @returns {Promise<Response>}
  */
 export async function renderResourceRouteRequest(options) {
-    const { request, route, params, routeModulePath } = options;
+    const { request, route, params, routeModulePath, globalMiddlewareModulePath = null } = options;
     try {
         const { result, setCookies = [] } = await executeRouteRequest({
             request,
             route: { ...route, route_kind: 'resource' },
             params,
-            routeModulePath
+            routeModulePath,
+            globalMiddlewareModulePath
         });
         return createResourceResponse(result, route.base_path || '/', setCookies);
     }

package/dist/types/generate-env-dts.js

@@ -1,54 +1,12 @@
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+import { renderZenithEnvDts } from './zenith-env-dts.js';
 /**
  * @param {string} projectRoot
  * @returns {Promise<void>}
  */
 export async function generateEnvDts(projectRoot) {
-    const content = `// .zenith/zenith-env.d.ts
-// Auto-generated by Zenith. Do not edit.
-
-export {};
-
-declare global {
-  namespace Zenith {
-    type Params = Record<string, string>;
-
-    interface LoadContext {
-      params: Params;
-      url: URL;
-      request: Request;
-      route: {
-        id: string;
-        file: string;
-        pattern: string;
-      };
-    }
-
-    interface ErrorState {
-      status?: number;
-      code?: string;
-      message: string;
-    }
-
-    type PageData = Record<string, unknown> & {
-      __zenith_error?: ErrorState;
-    };
-
-    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<T> | T;
-
-    type Renderable =
-      | string
-      | number
-      | boolean
-      | null
-      | undefined
-      | Renderable[]
-      | { __zenith_fragment: true };
-  }
-}
-`;
     const outPath = join(projectRoot, '.zenith', 'zenith-env.d.ts');
     await mkdir(dirname(outPath), { recursive: true });
-    await writeFile(outPath, content, 'utf8');
+    await writeFile(outPath, renderZenithEnvDts(), 'utf8');
 }

package/dist/types/zenith-env-dts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {string}
+ */
+export function renderZenithEnvDts(): string;

package/dist/types/zenith-env-dts.js

@@ -0,0 +1,96 @@
+/**
+ * @returns {string}
+ */
+export function renderZenithEnvDts() {
+    return [
+        '// Auto-generated by Zenith CLI. Do not edit manually.',
+        'export {};',
+        '',
+        'declare global {',
+        '  namespace Zenith {',
+        '    type Params = Record<string, string>;',
+        '',
+        '    interface ErrorState {',
+        '      status?: number;',
+        '      code?: string;',
+        '      message: string;',
+        '    }',
+        '',
+        '    type PageData = Record<string, unknown> & { __zenith_error?: ErrorState };',
+        '',
+        '    interface RouteMeta {',
+        '      id: string;',
+        '      file: string;',
+        '      pattern: string;',
+        '    }',
+        '',
+        '    type RouteSession = Record<string, unknown>;',
+        '',
+        '    type RequireSessionOptions =',
+        '      | { redirectTo: string; status?: 302 | 303 | 307 }',
+        '      | { deny: 401 | 403 | 404; message?: string };',
+        '',
+        '    type ActionState =',
+        '      | null',
+        '      | { ok: true; status: 200; data: unknown }',
+        '      | { ok: false; status: 400 | 422; data: unknown };',
+        '',
+        '    type AllowResult = { kind: "allow" };',
+        '    type RedirectResult = { kind: "redirect"; location: string; status: number };',
+        '    type DenyResult = { kind: "deny"; status: 401 | 403 | 404; message?: string };',
+        '    type DataResult<T extends PageData = PageData> = { kind: "data"; data: T };',
+        '    type InvalidResult<T = unknown> = { kind: "invalid"; data: T; status: 400 | 422 };',
+        '    type JsonResult<T = unknown> = { kind: "json"; data: T; status: number };',
+        '    type TextResult = { kind: "text"; body: string; status: number };',
+        '    type RouteDownloadBody = string | Uint8Array | ArrayBuffer;',
+        '    type RouteDownloadOptions = { filename: string; contentType?: string };',
+        '    type DownloadResult = { kind: "download"; body: string; bodyEncoding: "utf8" | "base64"; bodySize: number; filename: string; contentType: string; status: 200 };',
+        '',
+        '    interface LoadContext {',
+        '      params: Params;',
+        '      url: URL;',
+        '      headers: Record<string, string>;',
+        '      cookies: Record<string, string>;',
+        '      request: Request;',
+        '      method: string;',
+        '      route: RouteMeta;',
+        '      env: Record<string, unknown>;',
+        '      action: ActionState;',
+        '      auth: {',
+        '        getSession(): Promise<RouteSession | null>;',
+        '        requireSession(options: RequireSessionOptions): Promise<RouteSession>;',
+        '        signIn(sessionObject: RouteSession): Promise<void>;',
+        '        signOut(): Promise<void>;',
+        '      };',
+        '      allow(): AllowResult;',
+        '      redirect(location: string, status?: number): RedirectResult;',
+        '      deny(status: 401 | 403 | 404, message?: string): DenyResult;',
+        '      data<T extends PageData = PageData>(payload: T): DataResult<T>;',
+        '      invalid<T = unknown>(payload: T, status?: 400 | 422): InvalidResult<T>;',
+        '      json<T = unknown>(payload: T, status?: number): JsonResult<T>;',
+        '      text(body: string, status?: number): TextResult;',
+        '      download(body: RouteDownloadBody, options: RouteDownloadOptions): DownloadResult;',
+        '    }',
+        '',
+        '    type PageRouteResult<T extends PageData = PageData> = T | DataResult<T> | RedirectResult | DenyResult;',
+        '    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<PageRouteResult<T>> | PageRouteResult<T>;',
+        '',
+        '    interface Fragment {',
+        '      __zenith_fragment: true;',
+        '      mount: (anchor: Node | null) => void;',
+        '      unmount: () => void;',
+        '    }',
+        '',
+        '    type Renderable =',
+        '      | string',
+        '      | number',
+        '      | boolean',
+        '      | null',
+        '      | undefined',
+        '      | Renderable[]',
+        '      | Fragment;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+}

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "description": "Deterministic project orchestrator for Zenith framework",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
-  "bin": {
-    "zenith": "./dist/index.js"
-  },
   "exports": {
     ".": "./dist/index.js"
   },
@@ -38,8 +35,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "0.7.10",
-    "@zenithbuild/bundler": "0.7.10",
+    "@zenithbuild/compiler": "0.7.12",
+    "@zenithbuild/bundler": "0.7.12",
     "picocolors": "^1.1.1",
     "sharp": "^0.34.4"
   },