@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.33

package/src/adapters/shared/http/explicit-static-route-matcher.js

@@ -1,66 +1,59 @@
-import { appLogger } from "../../../global/app-logger.js";
-import { prepareExplicitStaticRender } from "./explicit-static-render-preparation.js";
-import { matchExplicitStaticPathPattern } from "../../abstract/segment-path-matcher.js";
-const EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS = {
-  missingIntegration: (routePath) => `View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page() and exported as default.`,
-  noRendererForIntegration: (integrationName) => `No renderer found for integration: ${integrationName}`
+import { appLogger } from '../../../global/app-logger.js';
+import { prepareExplicitStaticRender } from './explicit-static-render-preparation.js';
+import { matchExplicitStaticPathPattern } from '../../abstract/segment-path-matcher.js';
+export const EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS = {
+    missingIntegration: (routePath) => `View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page() and exported as default.`,
+    noRendererForIntegration: (integrationName) => `No renderer found for integration: ${integrationName}`,
 };
-class ExplicitStaticRouteMatcher {
-  appConfig;
-  routeRendererFactory;
-  staticRoutes;
-  constructor({ appConfig, routeRendererFactory, staticRoutes }) {
-    this.appConfig = appConfig;
-    this.routeRendererFactory = routeRendererFactory;
-    this.staticRoutes = staticRoutes;
-  }
-  /**
-   * Match a request URL against explicit static routes.
-   * Returns the matched route and extracted params, or null if no match.
-   */
-  match(url) {
-    const pathname = new URL(url).pathname;
-    for (const route of this.staticRoutes) {
-      const params = matchExplicitStaticPathPattern(route.path, pathname);
-      if (params !== null) {
-        return { route, params };
-      }
+/**
+ * Matches and renders explicit static routes declared through `app.static()`.
+ */
+export class ExplicitStaticRouteMatcher {
+    appConfig;
+    routeRendererFactory;
+    staticRoutes;
+    constructor({ appConfig, routeRendererFactory, staticRoutes }) {
+        this.appConfig = appConfig;
+        this.routeRendererFactory = routeRendererFactory;
+        this.staticRoutes = staticRoutes;
     }
-    return null;
-  }
-  /**
-   * Handle a matched explicit static route.
-   * Resolves the loader and renders the view using the appropriate integration renderer.
-   */
-  async handleMatch(match) {
-    const { route, params } = match;
-    try {
-      const mod = await route.loader();
-      const view = mod.default;
-      const {
-        renderer,
-        props,
-        view: renderableView
-      } = await prepareExplicitStaticRender({
-        routePath: route.path,
-        view,
-        params,
-        appConfig: this.appConfig,
-        runtimeOrigin: this.appConfig.baseUrl,
-        routeRendererFactory: this.routeRendererFactory,
-        errors: EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS
-      });
-      return renderer.renderToResponse(renderableView, props, {});
-    } catch (error) {
-      appLogger.error(
-        `Error rendering explicit static route ${route.path}:`,
-        error instanceof Error ? error : String(error)
-      );
-      throw error;
+    /**
+     * Match a request URL against explicit static routes.
+     * Returns the matched route and extracted params, or null if no match.
+     */
+    match(url) {
+        const pathname = new URL(url).pathname;
+        for (const route of this.staticRoutes) {
+            const params = matchExplicitStaticPathPattern(route.path, pathname);
+            if (params !== null) {
+                return { route, params };
+            }
+        }
+        return null;
+    }
+    /**
+     * Handle a matched explicit static route.
+     * Resolves the loader and renders the view using the appropriate integration renderer.
+     */
+    async handleMatch(match) {
+        const { route, params } = match;
+        try {
+            const mod = await route.loader();
+            const view = mod.default;
+            const { renderer, props, view: renderableView, } = await prepareExplicitStaticRender({
+                routePath: route.path,
+                view,
+                params,
+                appConfig: this.appConfig,
+                runtimeOrigin: this.appConfig.baseUrl,
+                routeRendererFactory: this.routeRendererFactory,
+                errors: EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS,
+            });
+            return renderer.renderToResponse(renderableView, props, {});
+        }
+        catch (error) {
+            appLogger.error(`Error rendering explicit static route ${route.path}:`, error instanceof Error ? error : String(error));
+            throw error;
+        }
     }
-  }
 }
-export {
-  EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS,
-  ExplicitStaticRouteMatcher
-};

package/src/adapters/shared/http/file-route-middleware-pipeline.js

@@ -1,78 +1,84 @@
-import { createRequire } from "../../../utils/locals-utils.js";
-import { ApiResponseBuilder } from "./api-response.js";
-import { runMiddlewareChain } from "./run-middleware-chain.js";
-import { LocalsAccessError } from "../../../errors/locals-access-error.js";
-const FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS = {
-  middlewareRequiresDynamic: (filePath) => `[ecopages] Page middleware requires cache: 'dynamic'. Page: ${filePath}`
+import { createRequire } from '../../../utils/locals-utils.js';
+import { ApiResponseBuilder } from './api-response.js';
+import { runMiddlewareChain } from './run-middleware-chain.js';
+import { LocalsAccessError } from '../../../errors/locals-access-error.js';
+export const FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS = {
+    middlewareRequiresDynamic: (filePath) => `[ecopages] Page middleware requires cache: 'dynamic'. Page: ${filePath}`,
 };
-class FileRouteMiddlewarePipeline {
-  cacheService;
-  constructor(cacheService) {
-    this.cacheService = cacheService;
-  }
-  /**
-   * Enforces the current middleware contract for file-routed pages.
-   *
-   * Middleware depends on request-scoped locals and therefore must not run when
-   * the page is treated as statically cacheable.
-   *
-   * @param input Middleware list, effective cache strategy, and page path.
-   * @throws LocalsAccessError When middleware is configured for a non-dynamic page.
-   */
-  assertValidConfiguration(input) {
-    if (input.middleware.length > 0 && input.pageCacheStrategy !== "dynamic") {
-      throw new LocalsAccessError(
-        FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.middlewareRequiresDynamic(input.filePath)
-      );
+/**
+ * Executes middleware for file-based page routes.
+ *
+ * This pipeline owns the middleware-specific rules that are distinct from route
+ * matching and rendering, including request-local storage, the middleware
+ * execution context, and the invariant that page middleware only runs for
+ * request-time dynamic rendering.
+ */
+export class FileRouteMiddlewarePipeline {
+    cacheService;
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+    }
+    /**
+     * Enforces the current middleware contract for file-routed pages.
+     *
+     * Middleware depends on request-scoped locals and therefore must not run when
+     * the page is treated as statically cacheable.
+     *
+     * @param input Middleware list, effective cache strategy, and page path.
+     * @throws LocalsAccessError When middleware is configured for a non-dynamic page.
+     */
+    assertValidConfiguration(input) {
+        if (input.middleware.length > 0 && input.pageCacheStrategy !== 'dynamic') {
+            throw new LocalsAccessError(FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.middlewareRequiresDynamic(input.filePath));
+        }
+    }
+    /**
+     * Creates the request-scoped middleware context used by page middleware.
+     *
+     * The context intentionally omits `render()` and `renderPartial()` because
+     * rendering is owned by the page route pipeline, not by middleware stages.
+     *
+     * @param input Request details and the mutable locals store.
+     * @returns Middleware execution context.
+     */
+    createContext(input) {
+        const context = {
+            request: input.request,
+            params: input.params,
+            response: new ApiResponseBuilder(),
+            server: null,
+            services: {
+                cache: this.cacheService,
+            },
+            locals: input.locals,
+            require: createRequire(() => context.locals),
+            json: (data, options) => {
+                if (options?.status)
+                    context.response.status(options.status);
+                if (options?.headers)
+                    context.response.headers(options.headers);
+                return context.response.json(data);
+            },
+            html: (content, options) => {
+                if (options?.status)
+                    context.response.status(options.status);
+                if (options?.headers)
+                    context.response.headers(options.headers);
+                return context.response.html(content);
+            },
+        };
+        return context;
+    }
+    /**
+     * Runs the middleware chain and eventually delegates to the render callback.
+     *
+     * Middleware may short-circuit by returning a response directly. If the chain
+     * completes, the supplied `renderResponse` callback is executed exactly once.
+     *
+     * @param input Middleware context, chain, and terminal render callback.
+     * @returns Response from middleware or final render stage.
+     */
+    async run(input) {
+        return runMiddlewareChain(input.middleware, input.context, input.renderResponse);
     }
-  }
-  /**
-   * Creates the request-scoped middleware context used by page middleware.
-   *
-   * The context intentionally omits `render()` and `renderPartial()` because
-   * rendering is owned by the page route pipeline, not by middleware stages.
-   *
-   * @param input Request details and the mutable locals store.
-   * @returns Middleware execution context.
-   */
-  createContext(input) {
-    const context = {
-      request: input.request,
-      params: input.params,
-      response: new ApiResponseBuilder(),
-      server: null,
-      services: {
-        cache: this.cacheService
-      },
-      locals: input.locals,
-      require: createRequire(() => context.locals),
-      json: (data, options) => {
-        if (options?.status) context.response.status(options.status);
-        if (options?.headers) context.response.headers(options.headers);
-        return context.response.json(data);
-      },
-      html: (content, options) => {
-        if (options?.status) context.response.status(options.status);
-        if (options?.headers) context.response.headers(options.headers);
-        return context.response.html(content);
-      }
-    };
-    return context;
-  }
-  /**
-   * Runs the middleware chain and eventually delegates to the render callback.
-   *
-   * Middleware may short-circuit by returning a response directly. If the chain
-   * completes, the supplied `renderResponse` callback is executed exactly once.
-   *
-   * @param input Middleware context, chain, and terminal render callback.
-   * @returns Response from middleware or final render stage.
-   */
-  async run(input) {
-    return runMiddlewareChain(input.middleware, input.context, input.renderResponse);
-  }
 }
-export {
-  FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS,
-  FileRouteMiddlewarePipeline
-};

package/src/adapters/shared/http/fs-server-response-factory.js

@@ -1,101 +1,106 @@
-import { STATUS_MESSAGE } from "../../../config/constants.js";
-import { appLogger } from "../../../global/app-logger.js";
-import { fileSystem } from "@ecopages/file-system";
-class FileSystemServerResponseFactory {
-  options;
-  constructor({ options }) {
-    this.options = options;
-  }
-  isHtml(contentType) {
-    return contentType === "text/html";
-  }
-  shouldEnableGzip(contentType) {
-    if (this.options.watchMode) return false;
-    const gzipEnabledExtensions = ["text/javascript", "text/css"];
-    return gzipEnabledExtensions.includes(contentType);
-  }
-  async createResponseWithBody(body, init = {
-    headers: {
-      "Content-Type": "text/html"
+import { STATUS_MESSAGE } from '../../../config/constants.js';
+import { appLogger } from '../../../global/app-logger.js';
+import { fileSystem } from '@ecopages/file-system';
+/**
+ * Builds HTTP responses for static files and shared file-system fallbacks.
+ */
+export class FileSystemServerResponseFactory {
+    options;
+    constructor({ options }) {
+        this.options = options;
     }
-  }) {
-    return new Response(body, init);
-  }
-  async createDefaultNotFoundResponse() {
-    return new Response(STATUS_MESSAGE[404], {
-      status: 404
-    });
-  }
-  /**
-   * Wraps already-rendered HTML in a 404 response envelope.
-   */
-  async createHtmlNotFoundResponse(body) {
-    return await this.createResponseWithBody(body, {
-      status: 404,
-      statusText: STATUS_MESSAGE[404],
-      headers: {
-        "Content-Type": "text/html"
-      }
-    });
-  }
-  async createDefaultServerErrorResponse() {
-    return new Response(STATUS_MESSAGE[500], {
-      status: 500,
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8"
-      }
-    });
-  }
-  /**
-   * Wraps already-rendered HTML in a 500 response envelope.
-   */
-  async createHtmlServerErrorResponse(body) {
-    return await this.createResponseWithBody(body, {
-      status: 500,
-      statusText: STATUS_MESSAGE[500],
-      headers: {
-        "Content-Type": "text/html"
-      }
-    });
-  }
-  /**
-   * Reads a static file response, returning `null` when the file is missing.
-   */
-  async createFileResponse(filePath, contentType) {
-    try {
-      let file;
-      const contentEncodingHeader = {};
-      if (this.shouldEnableGzip(contentType)) {
-        const gzipPath = `${filePath}.gz`;
-        if (fileSystem.exists(gzipPath)) {
-          file = fileSystem.readFileAsBuffer(gzipPath);
-          contentEncodingHeader["Content-Encoding"] = "gzip";
-          contentEncodingHeader["Vary"] = "Accept-Encoding";
-        } else {
-          appLogger.debug("Gzip file not found, serving uncompressed", gzipPath);
-          file = fileSystem.readFileAsBuffer(filePath);
-        }
-      } else {
-        file = fileSystem.readFileAsBuffer(filePath);
-      }
-      return await this.createResponseWithBody(file, {
+    isHtml(contentType) {
+        return contentType === 'text/html';
+    }
+    shouldEnableGzip(contentType) {
+        if (this.options.watchMode)
+            return false;
+        const gzipEnabledExtensions = ['text/javascript', 'text/css'];
+        return gzipEnabledExtensions.includes(contentType);
+    }
+    async createResponseWithBody(body, init = {
         headers: {
-          "Content-Type": contentType,
-          ...contentEncodingHeader
+            'Content-Type': 'text/html',
+        },
+    }) {
+        return new Response(body, init);
+    }
+    async createDefaultNotFoundResponse() {
+        return new Response(STATUS_MESSAGE[404], {
+            status: 404,
+        });
+    }
+    /**
+     * Wraps already-rendered HTML in a 404 response envelope.
+     */
+    async createHtmlNotFoundResponse(body) {
+        return await this.createResponseWithBody(body, {
+            status: 404,
+            statusText: STATUS_MESSAGE[404],
+            headers: {
+                'Content-Type': 'text/html',
+            },
+        });
+    }
+    async createDefaultServerErrorResponse() {
+        return new Response(STATUS_MESSAGE[500], {
+            status: 500,
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+            },
+        });
+    }
+    /**
+     * Wraps already-rendered HTML in a 500 response envelope.
+     */
+    async createHtmlServerErrorResponse(body) {
+        return await this.createResponseWithBody(body, {
+            status: 500,
+            statusText: STATUS_MESSAGE[500],
+            headers: {
+                'Content-Type': 'text/html',
+            },
+        });
+    }
+    /**
+     * Reads a static file response, returning `null` when the file is missing.
+     */
+    async createFileResponse(filePath, contentType) {
+        try {
+            let file;
+            const contentEncodingHeader = {};
+            if (this.shouldEnableGzip(contentType)) {
+                const gzipPath = `${filePath}.gz`;
+                if (fileSystem.exists(gzipPath)) {
+                    file = fileSystem.readFileAsBuffer(gzipPath);
+                    contentEncodingHeader['Content-Encoding'] = 'gzip';
+                    contentEncodingHeader['Vary'] = 'Accept-Encoding';
+                }
+                else {
+                    appLogger.debug('Gzip file not found, serving uncompressed', gzipPath);
+                    file = fileSystem.readFileAsBuffer(filePath);
+                }
+            }
+            else {
+                file = fileSystem.readFileAsBuffer(filePath);
+            }
+            return await this.createResponseWithBody(file, {
+                headers: {
+                    'Content-Type': contentType,
+                    ...contentEncodingHeader,
+                },
+            });
+        }
+        catch (error) {
+            const err = error;
+            const code = err.code || err.cause?.code;
+            if (code === 'ENOENT') {
+                appLogger.debug('File not found', filePath);
+            }
+            else {
+                appLogger.error('Error reading file', filePath, err);
+            }
+            return null;
         }
-      });
-    } catch (error) {
-      const err = error;
-      const code = err.code || err.cause?.code;
-      if (code === "ENOENT") {
-        appLogger.debug("File not found", filePath);
-      } else {
-        appLogger.error("Error reading file", filePath, err);
-      }
-      return null;
     }
-  }
 }
-export {
-  FileSystemServerResponseFactory
-};