@zenithbuild/cli 0.7.3 → 0.7.5

package/dist/server-output.js

@@ -3,6 +3,7 @@ import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { basename, dirname, extname, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { loadResourceRouteManifest } from './resource-manifest.js';
 const PACKAGE_REQUIRE = createRequire(import.meta.url);
 const RELATIVE_SPECIFIER_RE = /((?:import|export)\s+(?:[^'"]*?\s+from\s+)?|import\s*\()\s*(['"])([^'"]+)\2/g;
 const SERVER_RUNTIME_FILES = [
@@ -14,6 +15,10 @@ const SERVER_RUNTIME_FILES = [
         from: new URL('./server-contract.js', import.meta.url),
         to: 'server-contract.js'
     },
+    {
+        from: new URL('./auth/route-auth.js', import.meta.url),
+        to: 'auth/route-auth.js'
+    },
     {
         from: new URL('./base-path.js', import.meta.url),
         to: 'base-path.js'
@@ -29,8 +34,32 @@ const SERVER_RUNTIME_FILES = [
     {
         from: new URL('./images/shared.js', import.meta.url),
         to: 'images/shared.js'
+    },
+    {
+        from: new URL('./images/runtime.js', import.meta.url),
+        to: 'images/runtime.js'
+    },
+    {
+        from: new URL('./images/service.js', import.meta.url),
+        to: 'images/service.js'
+    },
+    {
+        from: new URL('./server-error.js', import.meta.url),
+        to: 'server-error.js'
+    },
+    {
+        from: new URL('./resource-response.js', import.meta.url),
+        to: 'resource-response.js'
+    },
+    {
+        from: new URL('./download-result.js', import.meta.url),
+        to: 'download-result.js'
     }
 ];
+const SPECIAL_SERVER_SPECIFIERS = new Map([
+    ['zenith:server-contract', 'server-contract.js'],
+    ['zenith:route-auth', 'auth/route-auth.js']
+]);
 function normalizeRouteName(routePath) {
     if (routePath === '/') {
         return 'index';
@@ -144,7 +173,7 @@ function outputPathForSource(projectRoot, modulesRoot, sourcePath) {
         : relativePath.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
     return join(modulesRoot, nextRelative);
 }
-async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts, seen }) {
+async function compileImportedModule({ projectRoot, modulesRoot, serverDir, sourcePath, ts, seen }) {
     if (seen.has(sourcePath)) {
         return outputPathForSource(projectRoot, modulesRoot, sourcePath);
     }
@@ -158,6 +187,12 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
     const source = await readFile(sourcePath, 'utf8');
     let output = transpileSource(ts, source, sourcePath);
     for (const specifier of gatherSpecifiers(output)) {
+        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
+        if (specialSpecifierPath) {
+            const nextSpecifier = relative(dirname(outPath), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
+            output = replaceSpecifier(output, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+            continue;
+        }
         if (!isRelativeSpecifier(specifier)) {
             continue;
         }
@@ -168,6 +203,7 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
         const compiledDependencyPath = await compileImportedModule({
             projectRoot,
             modulesRoot,
+            serverDir,
             sourcePath: resolvedPath,
             ts,
             seen
@@ -178,12 +214,18 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
     await writeFile(outPath, output, 'utf8');
     return outPath;
 }
-async function writeRouteModulePackage({ projectRoot, routeDir, route }) {
+async function writeRouteModulePackage({ projectRoot, serverDir, routeDir, route }) {
     const ts = resolveTypeScriptApi(projectRoot);
     const modulesRoot = join(routeDir, 'modules');
     const seen = new Set();
     let entryOutput = transpileSource(ts, route.server_script || '', route.server_script_path || 'route-entry.ts');
     for (const specifier of gatherSpecifiers(entryOutput)) {
+        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
+        if (specialSpecifierPath) {
+            const nextSpecifier = relative(join(routeDir, 'route'), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
+            entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+            continue;
+        }
         if (!isRelativeSpecifier(specifier)) {
             continue;
         }
@@ -194,6 +236,7 @@ async function writeRouteModulePackage({ projectRoot, routeDir, route }) {
         const compiledDependencyPath = await compileImportedModule({
             projectRoot,
             modulesRoot,
+            serverDir,
             sourcePath: resolvedPath,
             ts,
             seen
@@ -230,8 +273,15 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
     catch {
         routerManifest = { routes: [] };
     }
-    const routes = Array.isArray(routerManifest.routes) ? routerManifest.routes : [];
-    const serverRoutes = routes.filter((route) => route.server_script && route.prerender !== true);
+    const resourceManifest = await loadResourceRouteManifest(staticDir, basePath);
+    const pageRoutes = Array.isArray(routerManifest.routes) ? routerManifest.routes : [];
+    const serverRoutes = pageRoutes
+        .filter((route) => route.server_script && route.prerender !== true)
+        .map((route) => ({ ...route, route_kind: 'page' }))
+        .concat((Array.isArray(resourceManifest.routes) ? resourceManifest.routes : []).map((route) => ({
+        ...route,
+        route_kind: 'resource'
+    })));
     await mkdir(serverDir, { recursive: true });
     await copyRuntimeFiles(serverDir);
     const imageManifestSource = join(staticDir, '_zenith', 'image', 'manifest.json');
@@ -240,8 +290,10 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
         const name = normalizeRouteName(route.path);
         const routeDir = join(serverDir, 'routes', name);
         await mkdir(routeDir, { recursive: true });
-        const htmlSourcePath = join(staticDir, String(route.output || '').replace(/^\//, ''));
-        await copyOptionalFile(htmlSourcePath, join(routeDir, 'route', 'page.html'));
+        if (route.route_kind !== 'resource') {
+            const htmlSourcePath = join(staticDir, String(route.output || '').replace(/^\//, ''));
+            await copyOptionalFile(htmlSourcePath, join(routeDir, 'route', 'page.html'));
+        }
         let pageAssetFile = null;
         if (typeof route.page_asset === 'string' && route.page_asset.length > 0) {
             const assetSourcePath = join(staticDir, route.page_asset.replace(/^\//, ''));
@@ -251,18 +303,20 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             }
         }
         let imageManifestFile = null;
-        if (await copyOptionalFile(imageManifestSource, join(routeDir, 'route', 'image-manifest.json'))) {
+        if (route.route_kind !== 'resource' && await copyOptionalFile(imageManifestSource, join(routeDir, 'route', 'image-manifest.json'))) {
             imageManifestFile = 'image-manifest.json';
         }
         await writeRouteModulePackage({
             projectRoot,
+            serverDir,
             routeDir,
             route
         });
         const meta = {
             name,
             path: route.path,
-            output: route.output,
+            route_kind: route.route_kind || 'page',
+            output: route.output || null,
             base_path: basePath,
             page_asset: route.page_asset || null,
             page_asset_file: pageAssetFile,
@@ -270,12 +324,19 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             server_script_path: route.server_script_path || null,
             guard_module_ref: route.guard_module_ref || null,
             load_module_ref: route.load_module_ref || null,
+            action_module_ref: route.action_module_ref || null,
             has_guard: route.has_guard === true,
             has_load: route.has_load === true,
-            params: extractRouteParams(route.path),
-            image_manifest_file: imageManifestFile,
+            has_action: route.has_action === true,
+            params: Array.isArray(route.params) && route.params.length > 0
+                ? [...route.params]
+                : extractRouteParams(route.path),
+            image_manifest_file: route.route_kind === 'resource' ? null : imageManifestFile,
             image_config: config?.images || {}
         };
+        if (route.route_kind !== 'resource' && Array.isArray(route.image_materialization) && route.image_materialization.length > 0) {
+            meta.image_materialization = route.image_materialization;
+        }
         await writeFile(join(routeDir, 'route.json'), `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
         emittedRoutes.push(meta);
     }

package/dist/server-runtime/node-server.js

@@ -5,7 +5,9 @@ import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { appLocalRedirectLocation, imageEndpointPath, normalizeBasePath, routeCheckPath, stripBasePath } from '../base-path.js';
 import { handleImageRequest } from '../images/service.js';
-import { executeRouteRequest, renderRouteRequest } from './route-render.js';
+import { createTrustedOriginResolver } from '../request-origin.js';
+import { defaultRouteDenyMessage, logServerException, sanitizeRouteResult } from '../server-error.js';
+import { executeRouteRequest, renderResourceRouteRequest, renderRouteRequest } from './route-render.js';
 import { resolveRequestRoute } from './resolve-request-route.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -68,18 +70,6 @@ function toStaticFilePath(staticDir, pathname) {
     }
     return resolveWithinRoot(staticDir, resolvedPath);
 }
-function publicHost(host) {
-    if (host === '0.0.0.0' || host === '::') {
-        return '127.0.0.1';
-    }
-    return host;
-}
-function createRequestBase(req, fallbackOrigin) {
-    if (typeof req.headers.host === 'string' && req.headers.host.length > 0) {
-        return `http://${req.headers.host}`;
-    }
-    return fallbackOrigin;
-}
 async function createWebRequest(req, url) {
     const init = {
         method: req.method || 'GET',
@@ -107,9 +97,23 @@ async function createWebRequest(req, url) {
     }
     return new Request(url.toString(), init);
 }
+function getSetCookieValues(response) {
+    if (typeof response?.headers?.getSetCookie === 'function') {
+        return response.headers.getSetCookie();
+    }
+    const value = response?.headers?.get?.('set-cookie');
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
 async function sendFetchResponse(res, response, method) {
     res.statusCode = response.status;
+    const setCookies = getSetCookieValues(response);
+    if (setCookies.length > 0) {
+        res.setHeader('set-cookie', setCookies);
+    }
     for (const [key, value] of response.headers.entries()) {
+        if (key.toLowerCase() === 'set-cookie') {
+            continue;
+        }
         res.setHeader(key, value);
     }
     if (String(method || 'GET').toUpperCase() === 'HEAD') {
@@ -165,13 +169,16 @@ async function loadRuntimeContext(options = {}) {
             base_path: '/'
         });
         const serverManifest = await readJson(join(serverDir, 'manifest.json'), { routes: [] });
+        const allServerRoutes = Array.isArray(serverManifest.routes) ? serverManifest.routes : [];
         return {
             distDir,
             serverDir,
             staticDir: resolve(serverDir, config.static_dir || '../static'),
             buildManifest,
             buildRoutes: Array.isArray(buildManifest.routes) ? buildManifest.routes : [],
-            serverRoutes: Array.isArray(serverManifest.routes) ? serverManifest.routes : [],
+            serverRoutes: allServerRoutes,
+            pageServerRoutes: allServerRoutes.filter((route) => route?.route_kind !== 'resource'),
+            resourceServerRoutes: allServerRoutes.filter((route) => route?.route_kind === 'resource'),
             images: config.images || {},
             basePath: normalizeBasePath(config.base_path || '/')
         };
@@ -216,7 +223,7 @@ async function handleRouteCheck(req, res, url, context) {
     }
     let result = { kind: 'allow' };
     let routeId = buildResolved.route.path || '';
-    const serverResolved = resolveRequestRoute(canonicalTargetUrl, context.serverRoutes);
+    const serverResolved = resolveRequestRoute(canonicalTargetUrl, context.pageServerRoutes);
     if (serverResolved.matched && serverResolved.route) {
         routeId = serverResolved.route.route_id || serverResolved.route.name || serverResolved.route.path || routeId;
         try {
@@ -232,10 +239,11 @@ async function handleRouteCheck(req, res, url, context) {
             result = normalizeRouteCheckResult(execution.result, targetUrl, context.basePath);
         }
         catch (error) {
+            logServerException('node route-check failed', error);
             result = {
                 kind: 'deny',
                 status: 500,
-                message: String(error)
+                message: defaultRouteDenyMessage(500)
             };
         }
     }
@@ -247,13 +255,13 @@ async function handleRouteCheck(req, res, url, context) {
         Vary: 'Cookie'
     });
     res.end(JSON.stringify({
-        result,
+        result: sanitizeRouteResult(result),
         routeId,
         to: targetUrl.toString()
     }));
 }
 async function handleNodeRequest(req, res, context, serverOrigin) {
-    const url = new URL(req.url || '/', createRequestBase(req, serverOrigin));
+    const url = new URL(req.url || '/', serverOrigin);
     const canonicalPath = stripBasePath(url.pathname, context.basePath);
     if (url.pathname === routeCheckPath(context.basePath)) {
         await handleRouteCheck(req, res, url, context);
@@ -284,7 +292,20 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
         await sendStaticFile(res, assetPath, req.method);
         return;
     }
-    const serverResolved = resolveRequestRoute(canonicalUrl, context.serverRoutes);
+    const resourceResolved = resolveRequestRoute(canonicalUrl, context.resourceServerRoutes);
+    if (resourceResolved.matched && resourceResolved.route) {
+        const routeDir = join(context.serverDir, 'routes', resourceResolved.route.name);
+        const request = await createWebRequest(req, url);
+        const response = await renderResourceRouteRequest({
+            request,
+            route: resourceResolved.route,
+            params: resourceResolved.params,
+            routeModulePath: join(routeDir, 'route', 'entry.js')
+        });
+        await sendFetchResponse(res, response, req.method);
+        return;
+    }
+    const serverResolved = resolveRequestRoute(canonicalUrl, context.pageServerRoutes);
     if (serverResolved.matched && serverResolved.route) {
         const routeDir = join(context.serverDir, 'routes', serverResolved.route.name);
         const request = await createWebRequest(req, url);
@@ -294,9 +315,6 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
             params: serverResolved.params,
             routeModulePath: join(routeDir, 'route', 'entry.js'),
             shellHtmlPath: join(routeDir, 'route', 'page.html'),
-            pageAssetPath: serverResolved.route.page_asset_file
-                ? join(routeDir, 'route', serverResolved.route.page_asset_file)
-                : null,
             imageManifestPath: serverResolved.route.image_manifest_file
                 ? join(routeDir, 'route', serverResolved.route.image_manifest_file)
                 : null,
@@ -321,32 +339,50 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
     res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
     res.end('404 Not Found');
 }
-export async function createRequestHandler(options = {}) {
-    const context = await loadRuntimeContext(options);
-    const host = publicHost(options.host || '127.0.0.1');
-    const port = Number.isInteger(options.port) ? options.port : 3000;
-    const serverOrigin = `http://${host}:${port}`;
+function createNodeRequestHandler(context, resolveServerOrigin) {
     return async (req, res) => {
         try {
-            await handleNodeRequest(req, res, context, serverOrigin);
+            await handleNodeRequest(req, res, context, resolveServerOrigin());
         }
         catch (error) {
+            logServerException('node request handler failed', error);
             res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end(String(error));
+            res.end(defaultRouteDenyMessage(500));
         }
     };
 }
+export async function createRequestHandler(options = {}) {
+    const context = await loadRuntimeContext(options);
+    const resolveServerOrigin = createTrustedOriginResolver({
+        publicOrigin: options.publicOrigin,
+        host: options.host || '127.0.0.1',
+        port: Number.isInteger(options.port) ? options.port : undefined,
+        label: 'createRequestHandler()'
+    });
+    resolveServerOrigin();
+    return createNodeRequestHandler(context, resolveServerOrigin);
+}
 export async function createNodeServer(options = {}) {
     const { port = 3000, host = '127.0.0.1' } = options;
-    const handler = await createRequestHandler({ ...options, port, host });
+    const context = await loadRuntimeContext(options);
+    let actualPort = Number.isInteger(port) && port > 0 ? port : 0;
+    const resolveServerOrigin = createTrustedOriginResolver({
+        publicOrigin: options.publicOrigin,
+        host,
+        getPort: () => actualPort,
+        label: 'createNodeServer()'
+    });
+    const handler = createNodeRequestHandler(context, resolveServerOrigin);
     const server = createServer((req, res) => {
         void handler(req, res);
     });
     return new Promise((resolveServer) => {
         server.listen(port, host, () => {
+            const address = server.address();
+            actualPort = address && typeof address === 'object' ? address.port : port;
             resolveServer({
                 server,
-                port: server.address().port,
+                port: actualPort,
                 close: () => server.close()
             });
         });

package/dist/server-runtime/route-render.d.ts

@@ -8,7 +8,7 @@ export function extractInternalParams(requestUrl: any, route: any): {};
  *   routeModulePath: string,
  *   guardOnly?: boolean
  * }} options
- * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, load: string } }>}
+ * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
 export function executeRouteRequest(options: {
     request: Request;
@@ -30,8 +30,11 @@ export function executeRouteRequest(options: {
     };
     trace: {
         guard: string;
+        action: string;
         load: string;
     };
+    status?: number;
+    setCookies?: string[];
 }>;
 /**
  * @param {{
@@ -40,7 +43,6 @@ export function executeRouteRequest(options: {
  *   params: Record<string, string>,
  *   routeModulePath: string,
  *   shellHtmlPath: string,
- *   pageAssetPath?: string | null,
  *   imageManifestPath?: string | null,
  *   imageConfig?: Record<string, unknown>
  * }} options
@@ -58,7 +60,29 @@ export function renderRouteRequest(options: {
     params: Record<string, string>;
     routeModulePath: string;
     shellHtmlPath: string;
-    pageAssetPath?: string | null;
     imageManifestPath?: string | null;
     imageConfig?: Record<string, unknown>;
 }): Promise<Response>;
+/**
+ * @param {{
+ *   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
+ * }} options
+ * @returns {Promise<Response>}
+ */
+export function renderResourceRouteRequest(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;
+}): Promise<Response>;