@zenithbuild/cli 0.7.10 → 0.7.12

package/dist/scoped-server-data/types.d.ts

@@ -0,0 +1,74 @@
+export type ScopedServerDiagnosticSeverity = 'error' | 'warning';
+export interface ScopedServerDiagnostic {
+    code: string;
+    severity: ScopedServerDiagnosticSeverity;
+    message: string;
+    filePath: string;
+}
+export type ScopedServerOwnerKind = 'layout' | 'component';
+export type ScopedServerOwnerSyntax = 'variables' | 'explicit-data';
+export interface ScopedServerDataOwnerBase {
+    ownerKind: ScopedServerOwnerKind;
+    ownerPath: string;
+    syntax: ScopedServerOwnerSyntax;
+    serializedVariableNames: string[];
+    level1VariableNames?: string[];
+    exportName: 'data';
+}
+export interface ScopedServerDataOwner extends ScopedServerDataOwnerBase {
+    ownerKey: string;
+}
+export interface CompilerOptsLike {
+    typescriptDefault?: boolean;
+}
+export interface ScanRouteScopedServerOwnersOptions {
+    pageSource: string;
+    pageFile: string;
+    registry: Map<string, string>;
+    srcDir: string;
+    compilerOpts?: CompilerOptsLike;
+}
+export interface ScanRouteScopedServerOwnersResult {
+    owners: ScopedServerDataOwner[];
+    diagnostics: ScopedServerDiagnostic[];
+}
+export interface OwnerFileAnalysisResult {
+    owner: ScopedServerDataOwnerBase | null;
+    diagnostics: ScopedServerDiagnostic[];
+}
+export interface ScriptBlockPartition {
+    attrs: string;
+    body: string;
+}
+export type ScopedServerInstanceStrategy = 'singleton' | 'per-instance';
+export type ScopedServerStaticPropValue = string | number | boolean | null | ScopedServerStaticPropValue[] | {
+    [key: string]: ScopedServerStaticPropValue;
+};
+export type ScopedServerStaticProps = Record<string, ScopedServerStaticPropValue>;
+export interface ManifestScopedServerDataInstance {
+    key: string;
+    occurrenceId: string;
+    props: ScopedServerStaticProps;
+}
+export interface ManifestScopedServerDataEntry {
+    ownerKind: ScopedServerOwnerKind;
+    ownerKey: string;
+    syntax: ScopedServerOwnerSyntax;
+    exportName: 'data';
+    instanceStrategy: ScopedServerInstanceStrategy;
+    serializedVariableNames?: string[];
+    props?: ScopedServerStaticProps;
+    instances?: ManifestScopedServerDataInstance[];
+}
+export interface AnalyzeRouteScopedServerMetadataOptions {
+    pageSource: string;
+    pageFile: string;
+    registry: Map<string, string>;
+    srcDir: string;
+    compilerOpts?: CompilerOptsLike;
+}
+export interface AnalyzeRouteScopedServerMetadataResult {
+    hasScopedServerData: boolean;
+    scopedServerData: ManifestScopedServerDataEntry[];
+    diagnostics: ScopedServerDiagnostic[];
+}

package/dist/scoped-server-data/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server-contract/auth-control-flow.d.ts

@@ -0,0 +1 @@
+export function unwrapAuthControlFlow(error: any, where: any, allowedKinds: any): any;

package/dist/server-contract/auth-control-flow.js

@@ -0,0 +1,10 @@
+import { AUTH_CONTROL_FLOW_FLAG } from './constants.js';
+import { assertValidRouteResultShape } from './route-result-validation.js';
+export function unwrapAuthControlFlow(error, where, allowedKinds) {
+    if (!error || typeof error !== 'object' || error[AUTH_CONTROL_FLOW_FLAG] !== true) {
+        return null;
+    }
+    const result = error.result;
+    assertValidRouteResultShape(result, where, allowedKinds);
+    return result;
+}

package/dist/server-contract/resolve.d.ts

@@ -1,3 +1,22 @@
+export function runGlobalMiddlewareChain({ middlewareFn, ctx, runRoute }: {
+    middlewareFn: any;
+    ctx: any;
+    runRoute: any;
+}): Promise<{
+    result: any;
+    trace: any;
+} | undefined>;
+export function executeMatchedRoutePipeline({ exports, ctx, filePath, guardOnly, routeKind, globalMiddleware }: {
+    exports: any;
+    ctx: any;
+    filePath: any;
+    guardOnly?: boolean | undefined;
+    routeKind?: string | undefined;
+    globalMiddleware?: null | undefined;
+}): Promise<{
+    result: any;
+    trace: any;
+} | undefined>;
 export function resolveRouteResult({ exports, ctx, filePath, guardOnly, routeKind }: {
     exports: any;
     ctx: any;

package/dist/server-contract/resolve.js

@@ -1,9 +1,14 @@
-import { STAGED_SET_COOKIES_KEY } from './constants.js';
 import { validateServerExports } from './export-validation.js';
+import { unwrapAuthControlFlow } from './auth-control-flow.js';
 import { assertJsonSerializable } from './json-serializable.js';
 import { assertValidRouteResultShape, isRouteResultLike } from './route-result-validation.js';
+import { buildResolvedEnvelope } from './resolved-envelope.js';
 import { allow, data, text } from './result-helpers.js';
 import { invokeRouteStage } from './stage.js';
+const GLOBAL_MIDDLEWARE_RESULT_ERROR = 'Global middleware may only continue with next() or short-circuit with redirect() / deny() in V1.';
+const GLOBAL_MIDDLEWARE_DOUBLE_NEXT_ERROR = 'Global middleware called next() more than once.';
+const GLOBAL_MIDDLEWARE_POST_NEXT_ERROR = 'Global middleware cannot override the route result after next() in V1.';
+const GLOBAL_MIDDLEWARE_ALLOWED_KINDS = new Set(['redirect', 'deny']);
 function buildActionState(result) {
     if (!result || typeof result !== 'object') {
         return null;
@@ -24,18 +29,85 @@ function buildActionState(result) {
     }
     return null;
 }
-function buildResolvedEnvelope({ result, trace, status, ctx }) {
-    const envelope = { result, trace };
-    if (status !== undefined) {
-        envelope.status = status;
-    }
-    const setCookies = Array.isArray(ctx?.[STAGED_SET_COOKIES_KEY])
-        ? ctx[STAGED_SET_COOKIES_KEY].slice()
-        : [];
-    if (setCookies.length > 0) {
-        envelope.setCookies = setCookies;
-    }
-    return envelope;
+function createEmptyRouteTrace() {
+    return {
+        guard: 'none',
+        action: 'none',
+        load: 'none'
+    };
+}
+function createUnsupportedMiddlewareResultError() {
+    return new Error(GLOBAL_MIDDLEWARE_RESULT_ERROR);
+}
+function buildMiddlewareShortCircuitEnvelope(result, ctx) {
+    assertValidRouteResultShape(result, 'global middleware return', GLOBAL_MIDDLEWARE_ALLOWED_KINDS);
+    return buildResolvedEnvelope({
+        result,
+        trace: createEmptyRouteTrace(),
+        ctx
+    });
+}
+function normalizePreNextResult(result, ctx) {
+    if (!isRouteResultLike(result) || !GLOBAL_MIDDLEWARE_ALLOWED_KINDS.has(result.kind)) {
+        throw createUnsupportedMiddlewareResultError();
+    }
+    return buildMiddlewareShortCircuitEnvelope(result, ctx);
+}
+export async function runGlobalMiddlewareChain({ middlewareFn, ctx, runRoute }) {
+    if (typeof middlewareFn !== 'function' || typeof runRoute !== 'function') {
+        throw createUnsupportedMiddlewareResultError();
+    }
+    let nextCalled = false;
+    let capturedEnvelope;
+    const next = async () => {
+        if (nextCalled) {
+            throw new Error(GLOBAL_MIDDLEWARE_DOUBLE_NEXT_ERROR);
+        }
+        nextCalled = true;
+        capturedEnvelope = await runRoute();
+        return capturedEnvelope;
+    };
+    let middlewareResult;
+    try {
+        middlewareResult = await middlewareFn(ctx, next);
+    }
+    catch (error) {
+        const authResult = unwrapAuthControlFlow(error, 'global middleware return', GLOBAL_MIDDLEWARE_ALLOWED_KINDS);
+        if (authResult) {
+            return buildMiddlewareShortCircuitEnvelope(authResult, ctx);
+        }
+        throw error;
+    }
+    if (nextCalled) {
+        if (middlewareResult === undefined || middlewareResult === capturedEnvelope) {
+            return capturedEnvelope;
+        }
+        throw new Error(GLOBAL_MIDDLEWARE_POST_NEXT_ERROR);
+    }
+    if (middlewareResult === undefined) {
+        throw createUnsupportedMiddlewareResultError();
+    }
+    return normalizePreNextResult(middlewareResult, ctx);
+}
+export async function executeMatchedRoutePipeline({ exports, ctx, filePath, guardOnly = false, routeKind = 'page', globalMiddleware = null }) {
+    const runRoute = () => resolveRouteResult({
+        exports,
+        ctx,
+        filePath,
+        guardOnly,
+        routeKind
+    });
+    if (globalMiddleware == null) {
+        return runRoute();
+    }
+    if (typeof globalMiddleware !== 'function') {
+        throw createUnsupportedMiddlewareResultError();
+    }
+    return runGlobalMiddlewareChain({
+        middlewareFn: globalMiddleware,
+        ctx,
+        runRoute
+    });
 }
 export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = false, routeKind = 'page' }) {
     validateServerExports({ exports, filePath, routeKind });

package/dist/server-contract/resolved-envelope.d.ts

@@ -0,0 +1,9 @@
+export function buildResolvedEnvelope({ result, trace, status, ctx }: {
+    result: any;
+    trace: any;
+    status: any;
+    ctx: any;
+}): {
+    result: any;
+    trace: any;
+};

package/dist/server-contract/resolved-envelope.js

@@ -0,0 +1,14 @@
+import { STAGED_SET_COOKIES_KEY } from './constants.js';
+export function buildResolvedEnvelope({ result, trace, status, ctx }) {
+    const envelope = { result, trace };
+    if (status !== undefined) {
+        envelope.status = status;
+    }
+    const setCookies = Array.isArray(ctx?.[STAGED_SET_COOKIES_KEY])
+        ? ctx[STAGED_SET_COOKIES_KEY].slice()
+        : [];
+    if (setCookies.length > 0) {
+        envelope.setCookies = setCookies;
+    }
+    return envelope;
+}

package/dist/server-contract/stage.js

@@ -1,13 +1,4 @@
-import { AUTH_CONTROL_FLOW_FLAG } from './constants.js';
-import { assertValidRouteResultShape } from './route-result-validation.js';
-function unwrapAuthControlFlow(error, where, allowedKinds) {
-    if (!error || typeof error !== 'object' || error[AUTH_CONTROL_FLOW_FLAG] !== true) {
-        return null;
-    }
-    const result = error.result;
-    assertValidRouteResultShape(result, where, allowedKinds);
-    return result;
-}
+import { unwrapAuthControlFlow } from './auth-control-flow.js';
 export async function invokeRouteStage({ fn, ctx, where, allowedKinds }) {
     try {
         return await fn(ctx);

package/dist/server-module-output.d.ts

@@ -0,0 +1,9 @@
+export function writeServerModulePackage({ projectRoot, serverDir, entrySource, entrySourcePath, entryOutputPath, modulesRoot, validateMiddlewareImports }: {
+    projectRoot: any;
+    serverDir: any;
+    entrySource: any;
+    entrySourcePath: any;
+    entryOutputPath: any;
+    modulesRoot: any;
+    validateMiddlewareImports?: boolean | undefined;
+}): Promise<void>;

package/dist/server-module-output.js

@@ -0,0 +1,250 @@
+import { existsSync } from 'node:fs';
+import { cp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const RELATIVE_SPECIFIER_RE = /((?:import|export)\s+(?:[^'"]*?\s+from\s+)?|import\s*\()\s*(['"])([^'"]+)\2/g;
+const SPECIAL_SERVER_SPECIFIERS = new Map([
+    ['zenith:server-contract', 'server-contract.js'],
+    ['zenith:route-auth', 'auth/route-auth.js']
+]);
+const SERVER_MODULE_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.json'
+]);
+function resolveTypeScriptApi(projectRoot) {
+    try {
+        const projectRequire = createRequire(join(projectRoot, '__zenith_server_output_loader__.js'));
+        return projectRequire('typescript');
+    }
+    catch {
+        try {
+            return PACKAGE_REQUIRE('typescript');
+        }
+        catch {
+            throw new Error('[Zenith:Build] Server-capable targets require the `typescript` package to transpile route modules.');
+        }
+    }
+}
+function replaceSpecifier(source, original, nextValue) {
+    return source.replace(new RegExp(`(['"])${escapeRegex(original)}\\1`, 'g'), (_, quote) => `${quote}${nextValue}${quote}`);
+}
+function escapeRegex(value) {
+    return String(value).replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&');
+}
+function isRelativeSpecifier(specifier) {
+    return (specifier.startsWith('./') ||
+        specifier.startsWith('../') ||
+        specifier.startsWith('/') ||
+        specifier.startsWith('file:'));
+}
+function resolveModuleCandidates(basePath) {
+    if (extname(basePath)) {
+        return [basePath];
+    }
+    return [
+        basePath,
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        `${basePath}.mts`,
+        `${basePath}.cts`,
+        `${basePath}.js`,
+        `${basePath}.mjs`,
+        `${basePath}.cjs`,
+        `${basePath}.json`,
+        join(basePath, 'index.ts'),
+        join(basePath, 'index.tsx'),
+        join(basePath, 'index.mts'),
+        join(basePath, 'index.cts'),
+        join(basePath, 'index.js'),
+        join(basePath, 'index.mjs'),
+        join(basePath, 'index.cjs'),
+        join(basePath, 'index.json')
+    ];
+}
+function resolveImportedModule(specifier, sourceFile) {
+    if (!isRelativeSpecifier(specifier)) {
+        return null;
+    }
+    const baseDir = dirname(sourceFile);
+    const basePath = specifier.startsWith('file:')
+        ? new URL(specifier)
+        : resolve(baseDir, specifier);
+    const filePath = basePath instanceof URL ? fileURLToPath(basePath) : basePath;
+    const candidates = resolveModuleCandidates(filePath);
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (!found) {
+        throw new Error(`[Zenith:Build] Cannot resolve server import "${specifier}" from "${sourceFile}"`);
+    }
+    return found;
+}
+function gatherSpecifiers(source) {
+    const results = [];
+    for (const match of source.matchAll(RELATIVE_SPECIFIER_RE)) {
+        const specifier = String(match[3] || '');
+        results.push(specifier);
+    }
+    return results;
+}
+function transpileSource(ts, source, filePath) {
+    return ts.transpileModule(source, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2022,
+            moduleResolution: ts.ModuleResolutionKind.NodeNext,
+            esModuleInterop: true,
+            allowSyntheticDefaultImports: true
+        },
+        fileName: filePath
+    }).outputText;
+}
+function outputPathForSource(projectRoot, modulesRoot, sourcePath) {
+    const relativePath = relative(projectRoot, sourcePath).replaceAll('\\', '/');
+    const nextRelative = extname(relativePath) === '.json'
+        ? relativePath
+        : relativePath.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
+    return join(modulesRoot, nextRelative);
+}
+function assertSupportedMiddlewareImport(specifier, sourceFile) {
+    if (!isRelativeSpecifier(specifier)) {
+        return;
+    }
+    const extension = extname(specifier.startsWith('file:') ? fileURLToPath(new URL(specifier)) : specifier).toLowerCase();
+    if (!extension || SERVER_MODULE_EXTENSIONS.has(extension)) {
+        return;
+    }
+    throw new Error(`[Zenith:Middleware] Unsupported middleware import "${specifier}" from "${sourceFile}". ` +
+        'Global middleware may only import JavaScript, TypeScript, or JSON modules.');
+}
+function assertSupportedMiddlewareSourcePath(sourcePath, specifier, sourceFile) {
+    const extension = extname(sourcePath).toLowerCase();
+    if (SERVER_MODULE_EXTENSIONS.has(extension)) {
+        return;
+    }
+    throw new Error(`[Zenith:Middleware] Unsupported middleware import "${specifier}" from "${sourceFile}". ` +
+        'Global middleware may only import JavaScript, TypeScript, or JSON modules.');
+}
+function assertLiteralMiddlewareDynamicImports(ts, source, sourceFile) {
+    const parsed = ts.createSourceFile(sourceFile, String(source || ''), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    let invalid = false;
+    function visit(node) {
+        if (invalid) {
+            return;
+        }
+        if (ts.isCallExpression(node) &&
+            node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+            const firstArg = node.arguments?.[0];
+            if (!firstArg || !ts.isStringLiteralLike(firstArg)) {
+                invalid = true;
+                return;
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(parsed, visit);
+    if (invalid) {
+        throw new Error('[Zenith:Middleware] Dynamic middleware imports must use a string literal specifier.');
+    }
+}
+async function compileImportedModule({ projectRoot, modulesRoot, serverDir, sourcePath, sourceSpecifier, importerPath, ts, seen, validateMiddlewareImports = false }) {
+    if (seen.has(sourcePath)) {
+        return outputPathForSource(projectRoot, modulesRoot, sourcePath);
+    }
+    seen.add(sourcePath);
+    if (validateMiddlewareImports) {
+        assertSupportedMiddlewareSourcePath(sourcePath, sourceSpecifier, importerPath);
+    }
+    const outPath = outputPathForSource(projectRoot, modulesRoot, sourcePath);
+    await mkdir(dirname(outPath), { recursive: true });
+    if (extname(sourcePath) === '.json') {
+        await cp(sourcePath, outPath, { force: true });
+        return outPath;
+    }
+    const source = await readFile(sourcePath, 'utf8');
+    if (validateMiddlewareImports) {
+        assertLiteralMiddlewareDynamicImports(ts, source, sourcePath);
+    }
+    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;
+        }
+        if (validateMiddlewareImports) {
+            assertSupportedMiddlewareImport(specifier, sourcePath);
+        }
+        const resolvedPath = resolveImportedModule(specifier, sourcePath);
+        if (!resolvedPath) {
+            continue;
+        }
+        const compiledDependencyPath = await compileImportedModule({
+            projectRoot,
+            modulesRoot,
+            serverDir,
+            sourcePath: resolvedPath,
+            sourceSpecifier: specifier,
+            importerPath: sourcePath,
+            ts,
+            seen,
+            validateMiddlewareImports
+        });
+        const nextSpecifier = relative(dirname(outPath), compiledDependencyPath).replaceAll('\\', '/');
+        output = replaceSpecifier(output, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+    }
+    await writeFile(outPath, output, 'utf8');
+    return outPath;
+}
+export async function writeServerModulePackage({ projectRoot, serverDir, entrySource, entrySourcePath, entryOutputPath, modulesRoot, validateMiddlewareImports = false }) {
+    const ts = resolveTypeScriptApi(projectRoot);
+    const seen = new Set();
+    if (validateMiddlewareImports) {
+        assertLiteralMiddlewareDynamicImports(ts, entrySource, entrySourcePath);
+    }
+    let entryOutput = transpileSource(ts, entrySource || '', entrySourcePath || 'route-entry.ts');
+    for (const specifier of gatherSpecifiers(entryOutput)) {
+        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
+        if (specialSpecifierPath) {
+            const nextSpecifier = relative(dirname(entryOutputPath), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
+            entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+            continue;
+        }
+        if (!isRelativeSpecifier(specifier)) {
+            continue;
+        }
+        if (validateMiddlewareImports) {
+            assertSupportedMiddlewareImport(specifier, entrySourcePath);
+        }
+        const resolvedPath = resolveImportedModule(specifier, entrySourcePath || projectRoot);
+        if (!resolvedPath) {
+            continue;
+        }
+        const compiledDependencyPath = await compileImportedModule({
+            projectRoot,
+            modulesRoot,
+            serverDir,
+            sourcePath: resolvedPath,
+            sourceSpecifier: specifier,
+            importerPath: entrySourcePath,
+            ts,
+            seen,
+            validateMiddlewareImports
+        });
+        const nextSpecifier = relative(dirname(entryOutputPath), compiledDependencyPath).replaceAll('\\', '/');
+        entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+    }
+    await mkdir(dirname(entryOutputPath), { recursive: true });
+    await writeFile(entryOutputPath, entryOutput, 'utf8');
+}

package/dist/server-output.d.ts

@@ -1,9 +1,15 @@
-export function writeServerOutput({ coreOutputDir, staticDir, projectRoot, config, basePath }: {
+export function writeServerOutput({ coreOutputDir, staticDir, projectRoot, config, basePath, globalMiddleware, pageManifest, pagesDir, srcDir, registry, compilerOpts }: {
     coreOutputDir: any;
     staticDir: any;
     projectRoot: any;
     config: any;
     basePath?: string | undefined;
+    globalMiddleware?: null | undefined;
+    pageManifest?: never[] | undefined;
+    pagesDir?: null | undefined;
+    srcDir?: null | undefined;
+    registry?: null | undefined;
+    compilerOpts?: {} | undefined;
 }): Promise<{
     serverDir: string;
     routes: {