@zenithbuild/cli 0.7.11 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.7.11",
+  "version": "0.7.12",
   "description": "Deterministic project orchestrator for Zenith framework",
   "license": "MIT",
   "type": "module",
@@ -35,8 +35,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "0.7.11",
-    "@zenithbuild/bundler": "0.7.11",
+    "@zenithbuild/compiler": "0.7.12",
+    "@zenithbuild/bundler": "0.7.12",
     "picocolors": "^1.1.1",
     "sharp": "^0.34.4"
   },