@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.41

package/src/watchers/project-watcher.test-helpers.js

@@ -1,52 +1,47 @@
-import { vi } from "vitest";
-const createMockHmrManager = () => ({
-  handleFileChange: vi.fn(async () => {
-  }),
-  broadcast: vi.fn(() => {
-  }),
-  setEnabled: vi.fn(() => {
-  }),
-  setPlugins: vi.fn(() => {
-  }),
-  registerEntrypoint: vi.fn(async () => ""),
-  registerScriptEntrypoint: vi.fn(async () => ""),
-  registerStrategy: vi.fn(() => {
-  }),
-  isEnabled: vi.fn(() => true),
-  getOutputUrl: vi.fn(() => void 0),
-  getWatchedFiles: vi.fn(() => /* @__PURE__ */ new Map()),
-  getDistDir: vi.fn(() => ""),
-  getPlugins: vi.fn(() => []),
-  getDefaultContext: vi.fn(() => ({
-    getWatchedFiles: () => /* @__PURE__ */ new Map(),
-    getDistDir: () => "",
-    getPlugins: () => [],
-    getSrcDir: () => "",
-    getLayoutsDir: () => "",
-    getPagesDir: () => "",
-    getBuildExecutor: () => ({ build: vi.fn(async () => ({ success: true, logs: [], outputs: [] })) }),
-    getBrowserBundleService: () => ({ bundle: vi.fn(async () => ({ success: true, logs: [], outputs: [] })) }),
-    importServerModule: vi.fn(async () => ({}))
-  }))
+import { vi } from 'vitest';
+export const createMockHmrManager = () => ({
+    handleFileChange: vi.fn(async () => { }),
+    broadcast: vi.fn(() => { }),
+    setEnabled: vi.fn(() => { }),
+    registerEntrypoint: vi.fn(async () => ''),
+    registerDevTransformContributor: vi.fn(() => { }),
+    registerScriptEntrypoint: vi.fn(async () => ({
+        sourcePath: '',
+        outputPath: '',
+        outputUrl: '',
+        role: 'script',
+    })),
+    registerStrategy: vi.fn(() => { }),
+    isEnabled: vi.fn(() => true),
+    getOutputUrl: vi.fn(() => undefined),
+    getWatchedFiles: vi.fn(() => new Map()),
+    getRegisteredEntrypoints: vi.fn(() => new Map()),
+    getRuntimeWorkDir: vi.fn(() => ''),
+    getRuntimePath: vi.fn(() => ''),
+    tryHandleAssetRequest: vi.fn(() => null),
+    getDefaultContext: vi.fn(() => ({
+        getWatchedFiles: () => new Map(),
+        getRegisteredEntrypoints: () => new Map(),
+        getSrcDir: () => '',
+        getLayoutsDir: () => '',
+        getPagesDir: () => '',
+        getEntrypointDependencyGraph: () => ({
+            supportsSelectiveInvalidation: () => false,
+            getDependencyEntrypoints: () => new Set(),
+            setEntrypointDependencies: () => { },
+            clearEntrypointDependencies: () => { },
+            reset: () => { },
+        }),
+        importServerModule: vi.fn(async () => ({})),
+    })),
 });
-const createMockBridge = () => ({
-  reload: vi.fn(() => {
-  }),
-  error: vi.fn(() => {
-  }),
-  cssUpdate: vi.fn(() => {
-  }),
-  update: vi.fn(() => {
-  }),
-  subscribe: vi.fn(() => {
-  }),
-  unsubscribe: vi.fn(() => {
-  }),
-  broadcast: vi.fn(() => {
-  }),
-  subscriberCount: 0
+export const createMockBridge = () => ({
+    reload: vi.fn(() => { }),
+    error: vi.fn(() => { }),
+    cssUpdate: vi.fn(() => { }),
+    update: vi.fn(() => { }),
+    subscribe: vi.fn(() => { }),
+    unsubscribe: vi.fn(() => { }),
+    broadcast: vi.fn(() => { }),
+    subscriberCount: 0,
 });
-export {
-  createMockBridge,
-  createMockHmrManager
-};

package/src/adapters/shared/api-response.js

@@ -1,96 +0,0 @@
-class ApiResponseBuilder {
-  _status = 200;
-  _headers = new Headers();
-  /**
-   * Sets the HTTP status code for the response.
-   * @param code - The HTTP status code.
-   * @returns The builder instance for chaining.
-   */
-  status(code) {
-    this._status = code;
-    return this;
-  }
-  /**
-   * Adds or merges headers for the response.
-   * @param headersInit - Headers to add or merge.
-   * @returns The builder instance for chaining.
-   */
-  headers(headersInit) {
-    const inputHeaders = new Headers(headersInit);
-    inputHeaders.forEach((value, key) => {
-      this._headers.set(key, value);
-    });
-    return this;
-  }
-  /**
-   * Creates a JSON response using the configured status and headers.
-   * @param data - The data to serialize.
-   * @returns A Response object.
-   */
-  json(data) {
-    if (!this._headers.has("Content-Type")) {
-      this._headers.set("Content-Type", "application/json; charset=utf-8");
-    }
-    return new Response(JSON.stringify(data), { status: this._status, headers: this._headers });
-  }
-  /**
-   * Creates a plain text response using the configured status and headers.
-   * @param data - The text content.
-   * @returns A Response object.
-   */
-  text(data) {
-    if (!this._headers.has("Content-Type")) {
-      this._headers.set("Content-Type", "text/plain; charset=utf-8");
-    }
-    return new Response(data, { status: this._status, headers: this._headers });
-  }
-  /**
-   * Creates an HTML response using the configured status and headers.
-   * @param data - The HTML content.
-   * @returns A Response object.
-   */
-  html(data) {
-    if (!this._headers.has("Content-Type")) {
-      this._headers.set("Content-Type", "text/html; charset=utf-8");
-    }
-    return new Response(data, { status: this._status, headers: this._headers });
-  }
-  /**
-   * Creates a redirect response.
-   * @param url - The URL to redirect to.
-   * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 302 if not set via status().
-   * @returns A Response object.
-   */
-  redirect(url, explicitStatus) {
-    const redirectStatus = explicitStatus ?? (this._status === 200 ? 302 : this._status);
-    this._headers.set("Location", url);
-    return new Response(null, { status: redirectStatus, headers: this._headers });
-  }
-  /**
-   * Creates an error response using the configured status and headers.
-   * If data is an object, it's treated as JSON, otherwise as text.
-   * @param data - The error data (string or object).
-   * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 500 if not set via status().
-   * @returns A Response object.
-   */
-  error(data, explicitStatus) {
-    const errorStatus = explicitStatus ?? (this._status === 200 ? 500 : this._status);
-    this.status(errorStatus);
-    if (typeof data === "object" && data !== null) {
-      if (!this._headers.has("Content-Type")) {
-        this._headers.set("Content-Type", "application/json; charset=utf-8");
-      }
-      return new Response(JSON.stringify({ error: data }), {
-        status: this._status,
-        headers: this._headers
-      });
-    }
-    if (!this._headers.has("Content-Type")) {
-      this._headers.set("Content-Type", "text/plain; charset=utf-8");
-    }
-    return new Response(String(data), { status: this._status, headers: this._headers });
-  }
-}
-export {
-  ApiResponseBuilder
-};

package/src/adapters/shared/application-adapter.js

@@ -1,90 +0,0 @@
-import {
-  AbstractApplicationAdapter
-} from "../abstract/application-adapter.js";
-class SharedApplicationAdapter extends AbstractApplicationAdapter {
-  register(path, method, handler, options) {
-    return this.addRouteHandler(path, method, handler, options?.middleware, options?.schema);
-  }
-  get(path, handler, options) {
-    return this.register(path, "GET", handler, options);
-  }
-  post(path, handler, options) {
-    return this.register(path, "POST", handler, options);
-  }
-  put(path, handler, options) {
-    return this.register(path, "PUT", handler, options);
-  }
-  delete(path, handler, options) {
-    return this.register(path, "DELETE", handler, options);
-  }
-  patch(path, handler, options) {
-    return this.register(path, "PATCH", handler, options);
-  }
-  options(path, handler, options) {
-    return this.register(path, "OPTIONS", handler, options);
-  }
-  head(path, handler, options) {
-    return this.register(path, "HEAD", handler, options);
-  }
-  route(path, method, handler, options) {
-    return this.register(path, method, handler, options);
-  }
-  add(handler) {
-    return this.addRouteHandler(handler.path, handler.method, handler.handler, handler.middleware, handler.schema);
-  }
-  group(prefixOrGroup, callback, options) {
-    if (typeof prefixOrGroup === "object") {
-      return this.registerGroup(prefixOrGroup);
-    }
-    const normalizedPrefix = prefixOrGroup.endsWith("/") ? prefixOrGroup.slice(0, -1) : prefixOrGroup;
-    const groupMiddleware = options?.middleware ?? [];
-    const createHandler = (method) => {
-      return ((path, handler, routeOptions) => {
-        const combinedMiddleware = [
-          ...groupMiddleware,
-          ...routeOptions?.middleware ?? []
-        ];
-        const fullPath = path === "/" ? normalizedPrefix : `${normalizedPrefix}${path}`;
-        this.addRouteHandler(
-          fullPath,
-          method,
-          handler,
-          combinedMiddleware.length > 0 ? combinedMiddleware : void 0,
-          routeOptions?.schema
-        );
-        return builder;
-      });
-    };
-    const builder = {
-      get: createHandler("GET"),
-      post: createHandler("POST"),
-      put: createHandler("PUT"),
-      delete: createHandler("DELETE"),
-      patch: createHandler("PATCH"),
-      options: createHandler("OPTIONS"),
-      head: createHandler("HEAD")
-    };
-    callback?.(builder);
-    return this;
-  }
-  registerGroup(group) {
-    const normalizedPrefix = group.prefix.endsWith("/") ? group.prefix.slice(0, -1) : group.prefix;
-    const groupMiddleware = group.middleware ?? [];
-    for (const route of group.routes) {
-      const normalizedPath = route.path.startsWith("/") ? route.path : `/${route.path}`;
-      const fullPath = route.path === "/" ? normalizedPrefix : `${normalizedPrefix}${normalizedPath}`;
-      const combinedMiddleware = [...groupMiddleware, ...route.middleware ?? []];
-      this.addRouteHandler(
-        fullPath,
-        route.method,
-        route.handler,
-        combinedMiddleware.length > 0 ? combinedMiddleware : void 0,
-        route.schema
-      );
-    }
-    return this;
-  }
-}
-export {
-  SharedApplicationAdapter
-};

package/src/adapters/shared/define-api-handler.d.ts

@@ -1,25 +0,0 @@
-import type { ApiHandler, ApiHandlerContext, Middleware, RouteSchema, TypedGroupHandlerContext } from '../../types/public-types.js';
-type UniversalContext = ApiHandlerContext<Request, unknown>;
-type SchemaHandlerContext<TSchema extends RouteSchema | undefined, TContext extends UniversalContext> = TSchema extends RouteSchema ? TypedGroupHandlerContext<TSchema, TContext> : TContext;
-export declare function defineApiHandler<TPath extends string, TSchema extends RouteSchema | undefined = undefined, TContext extends UniversalContext = UniversalContext>(handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
-    handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
-    middleware?: Middleware<Request, unknown, TContext>[];
-    schema?: TSchema;
-}): ApiHandler<TPath, Request, unknown>;
-export interface GroupHandler<TPrefix extends string = string> {
-    prefix: TPrefix;
-    middleware?: readonly Middleware<Request, unknown, any>[];
-    routes: readonly ApiHandler<string, Request, unknown>[];
-}
-type GroupDefineHandler<TContext extends UniversalContext> = <const TPath extends string, TSchema extends RouteSchema | undefined = undefined>(handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
-    path: TPath;
-    handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
-    middleware?: Middleware<Request, unknown, TContext>[];
-    schema?: TSchema;
-}) => ApiHandler<TPath, Request, unknown>;
-export declare function defineGroupHandler<TPrefix extends string, TMiddleware extends readonly Middleware<Request, unknown, any>[] = [], TContext extends UniversalContext = TMiddleware extends readonly Middleware<Request, unknown, infer TGroupContext>[] ? TGroupContext : UniversalContext>(config: {
-    prefix: TPrefix;
-    middleware?: TMiddleware;
-    routes: (define: GroupDefineHandler<TContext>) => readonly ApiHandler<string, Request, unknown>[];
-}): GroupHandler<TPrefix>;
-export {};

package/src/adapters/shared/define-api-handler.js

@@ -1,15 +0,0 @@
-function defineApiHandler(handler) {
-  return handler;
-}
-function defineGroupHandler(config) {
-  const define = ((handler) => handler);
-  return {
-    prefix: config.prefix,
-    middleware: config.middleware,
-    routes: config.routes(define)
-  };
-}
-export {
-  defineApiHandler,
-  defineGroupHandler
-};

package/src/adapters/shared/explicit-static-render-preparation.js

@@ -1,26 +0,0 @@
-function getViewIntegrationName(view) {
-  return view.config?.integration ?? view.config?.__eco?.integration;
-}
-async function prepareExplicitStaticRender(input) {
-  const integrationName = getViewIntegrationName(input.view);
-  if (!integrationName) {
-    throw new Error(input.errors.missingIntegration(input.routePath));
-  }
-  const renderer = input.routeRendererFactory.getExplicitViewRenderer(integrationName);
-  if (!renderer) {
-    throw new Error(input.errors.noRendererForIntegration(integrationName));
-  }
-  const props = input.view.staticProps ? (await input.view.staticProps({
-    pathname: { params: input.params },
-    appConfig: input.appConfig,
-    runtimeOrigin: input.runtimeOrigin
-  })).props : {};
-  return {
-    renderer,
-    props,
-    view: input.view
-  };
-}
-export {
-  prepareExplicitStaticRender
-};

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

@@ -1,101 +0,0 @@
-import { appLogger } from "../../global/app-logger.js";
-import { prepareExplicitStaticRender } from "./explicit-static-render-preparation.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}`
-};
-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 = this.matchRoute(route.path, pathname);
-      if (params !== null) {
-        return { route, params };
-      }
-    }
-    return null;
-  }
-  /**
-   * Match a route pattern against a pathname.
-   * Supports :param and [param] syntax.
-   * Returns extracted params or null if no match.
-   */
-  matchRoute(pattern, pathname) {
-    const patternSegments = pattern.split("/").filter(Boolean);
-    const pathSegments = pathname.split("/").filter(Boolean);
-    if (patternSegments.length !== pathSegments.length) {
-      const lastPattern = patternSegments[patternSegments.length - 1];
-      const isCatchAll = lastPattern?.startsWith("[...") || lastPattern?.startsWith(":...");
-      if (!isCatchAll) {
-        return null;
-      }
-    }
-    const params = {};
-    for (let i = 0; i < patternSegments.length; i++) {
-      const patternPart = patternSegments[i];
-      const pathPart = pathSegments[i];
-      if (patternPart.startsWith(":...") || patternPart.startsWith("[...")) {
-        const paramName = patternPart.replace(/^(:\.\.\.|\[\.\.\.)/, "").replace(/\]$/, "");
-        params[paramName] = pathSegments.slice(i).join("/");
-        return params;
-      }
-      if (patternPart.startsWith(":")) {
-        const paramName = patternPart.slice(1);
-        params[paramName] = pathPart;
-      } else if (patternPart.startsWith("[") && patternPart.endsWith("]")) {
-        const paramName = patternPart.slice(1, -1);
-        params[paramName] = pathPart;
-      } else if (patternPart !== pathPart) {
-        return null;
-      }
-    }
-    return params;
-  }
-  /**
-   * 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/file-route-middleware-pipeline.js

@@ -1,90 +0,0 @@
-import { createRequire } from "../../utils/locals-utils.js";
-import { ApiResponseBuilder } from "./api-response.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}`
-};
-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) => {
-        const builder = new ApiResponseBuilder();
-        if (options?.status) builder.status(options.status);
-        if (options?.headers) builder.headers(options.headers);
-        return builder.json(data);
-      },
-      html: (content, options) => {
-        const builder = new ApiResponseBuilder();
-        if (options?.status) builder.status(options.status);
-        if (options?.headers) builder.headers(options.headers);
-        return builder.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) {
-    if (input.middleware.length === 0) {
-      return input.renderResponse();
-    }
-    let index = 0;
-    const executeNext = async () => {
-      if (index < input.middleware.length) {
-        const current = input.middleware[index++];
-        return current(input.context, executeNext);
-      }
-      return input.renderResponse();
-    };
-    return executeNext();
-  }
-}
-export {
-  FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS,
-  FileRouteMiddlewarePipeline
-};

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

@@ -1,81 +0,0 @@
-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"
-    }
-  }) {
-    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"
-      }
-    });
-  }
-  /**
-   * 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;
-    }
-  }
-}
-export {
-  FileSystemServerResponseFactory
-};