@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/services/schema-validation-service.d.ts

@@ -1,122 +0,0 @@
-import type { StandardSchema } from './validation/standard-schema.types.js';
-export interface ValidationResult<T = unknown> {
-    success: boolean;
-    data?: T;
-    errors?: Array<{
-        message: string;
-        path?: Array<string | number>;
-    }>;
-}
-export interface ValidationSource {
-    body?: unknown;
-    query?: Record<string, string>;
-    headers?: Record<string, string>;
-    params?: Record<string, string>;
-}
-export interface ValidationSchemas {
-    body?: StandardSchema;
-    query?: StandardSchema;
-    headers?: StandardSchema;
-    params?: StandardSchema;
-}
-export interface ValidatedData {
-    body?: unknown;
-    query?: unknown;
-    headers?: unknown;
-    params?: unknown;
-}
-/**
- * Service for validating request data using Standard Schema compliant validators.
- *
- * This service provides a unified interface for validating HTTP request data (body, query parameters, headers)
- * using any validation library that implements the Standard Schema specification.
- *
- * @example Using with Zod
- * ```typescript
- * import { z } from 'zod';
- * import { SchemaValidationService } from './schema-validation-service.js';
- *
- * const service = new SchemaValidationService();
- * const result = await service.validateRequest(
- *   { body: { title: 'Hello', count: 42 } },
- *   { body: z.object({ title: z.string(), count: z.number() }) }
- * );
- *
- * if (result.success) {
- *   console.log(result.data.body);
- * }
- * ```
- *
- * @example Using with Valibot
- * ```typescript
- * import * as v from 'valibot';
- *
- * const result = await service.validateRequest(
- *   { query: { page: '1' } },
- *   { query: v.object({ page: v.string() }) }
- * );
- * ```
- *
- * @example Using with ArkType
- * ```typescript
- * import { type } from 'arktype';
- *
- * const result = await service.validateRequest(
- *   { headers: { 'authorization': 'Bearer token' } },
- *   { headers: type({ authorization: 'string' }) }
- * );
- * ```
- *
- * @example Multiple sources
- * ```typescript
- * const result = await service.validateRequest(
- *   {
- *     body: { title: 'Post' },
- *     query: { format: 'json' },
- *     headers: { 'content-type': 'application/json' }
- *   },
- *   {
- *     body: z.object({ title: z.string() }),
- *     query: v.object({ format: v.string() }),
- *     headers: type({ 'content-type': 'string' })
- *   }
- * );
- * ```
- *
- * Supported libraries: Zod, Valibot, ArkType, Effect Schema (with standardSchemaV1 wrapper)
- */
-export declare class SchemaValidationService {
-    /**
-     * Validates request data against provided schemas.
-     *
-     * Validates body, query parameters, and headers against their respective schemas.
-     * All validations are performed, and errors are aggregated from all sources.
-     *
-     * @param source - The data to validate (body, query, headers)
-     * @param schemas - The Standard Schema validators for each source
-     * @returns Validation result with validated data or aggregated errors
-     *
-     * @example
-     * ```typescript
-     * const result = await service.validateRequest(
-     *   { body: { name: 'John', age: 30 } },
-     *   { body: z.object({ name: z.string(), age: z.number() }) }
-     * );
-     *
-     * if (result.success) {
-     *   const validated = result.data.body;
-     * } else {
-     *   console.error(result.errors);
-     * }
-     * ```
-     */
-    validateRequest(source: ValidationSource, schemas: ValidationSchemas): Promise<ValidationResult<ValidatedData>>;
-    /**
-     * Validates a single value against a Standard Schema.
-     *
-     * @param schema - The Standard Schema validator
-     * @param data - The data to validate
-     * @returns Validation result with validated data or errors
-     */
-    private validateWithSchema;
-}

package/src/services/schema-validation-service.js

@@ -1,101 +0,0 @@
-class SchemaValidationService {
-  /**
-   * Validates request data against provided schemas.
-   *
-   * Validates body, query parameters, and headers against their respective schemas.
-   * All validations are performed, and errors are aggregated from all sources.
-   *
-   * @param source - The data to validate (body, query, headers)
-   * @param schemas - The Standard Schema validators for each source
-   * @returns Validation result with validated data or aggregated errors
-   *
-   * @example
-   * ```typescript
-   * const result = await service.validateRequest(
-   *   { body: { name: 'John', age: 30 } },
-   *   { body: z.object({ name: z.string(), age: z.number() }) }
-   * );
-   *
-   * if (result.success) {
-   *   const validated = result.data.body;
-   * } else {
-   *   console.error(result.errors);
-   * }
-   * ```
-   */
-  async validateRequest(source, schemas) {
-    const validated = {};
-    const allErrors = [];
-    if (schemas.body && source.body !== void 0) {
-      const result = await this.validateWithSchema(schemas.body, source.body);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.body = result.data;
-      }
-    }
-    if (schemas.query && source.query) {
-      const result = await this.validateWithSchema(schemas.query, source.query);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.query = result.data;
-      }
-    }
-    if (schemas.headers && source.headers) {
-      const result = await this.validateWithSchema(schemas.headers, source.headers);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.headers = result.data;
-      }
-    }
-    if (schemas.params && source.params) {
-      const result = await this.validateWithSchema(schemas.params, source.params);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.params = result.data;
-      }
-    }
-    if (allErrors.length > 0) {
-      return { success: false, errors: allErrors };
-    }
-    return { success: true, data: validated };
-  }
-  /**
-   * Validates a single value against a Standard Schema.
-   *
-   * @param schema - The Standard Schema validator
-   * @param data - The data to validate
-   * @returns Validation result with validated data or errors
-   */
-  async validateWithSchema(schema, data) {
-    try {
-      const resultOrPromise = schema["~standard"].validate(data);
-      const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
-      if (result.issues) {
-        return {
-          success: false,
-          errors: result.issues.map((issue) => ({
-            message: issue.message,
-            path: issue.path?.map((p) => typeof p === "object" && "key" in p ? p.key : p)
-          }))
-        };
-      }
-      return { success: true, data: result.value };
-    } catch (error) {
-      return {
-        success: false,
-        errors: [
-          {
-            message: error instanceof Error ? error.message : "Validation failed"
-          }
-        ]
-      };
-    }
-  }
-}
-export {
-  SchemaValidationService
-};

package/src/services/validation/standard-schema.types.d.ts

@@ -1,65 +0,0 @@
-/**
- * Standard Schema interface for universal validation.
- * Compatible with Zod, Valibot, ArkType, Effect Schema, and other validation libraries.
- *
- * @see https://standardschema.dev
- *
- * @example Using with Zod
- * ```typescript
- * import { z } from 'zod';
- *
- * const bodySchema = z.object({
- *   title: z.string().min(1),
- *   content: z.string()
- * });
- *
- * app.post('/posts', async (ctx) => {
- *   const { title, content } = ctx.body;
- *   return ctx.json({ id: 1, title, content });
- * }, {
- *   schema: { body: bodySchema }
- * });
- * ```
- */
-export interface StandardSchema<Input = unknown, Output = Input> {
-    readonly '~standard': {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
-        readonly types?: {
-            readonly input: Input;
-            readonly output: Output;
-        };
-    };
-}
-/**
- * Result of Standard Schema validation.
- */
-export type StandardSchemaResult<Output> = StandardSchemaSuccessResult<Output> | StandardSchemaFailureResult;
-/**
- * Successful validation result.
- */
-export interface StandardSchemaSuccessResult<Output> {
-    readonly value: Output;
-    readonly issues?: undefined;
-}
-/**
- * Failed validation result.
- */
-export interface StandardSchemaFailureResult {
-    readonly value?: undefined;
-    readonly issues: ReadonlyArray<StandardSchemaIssue>;
-}
-/**
- * Validation issue details.
- */
-export interface StandardSchemaIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        key: PropertyKey;
-    }>;
-}
-/**
- * Infers the output type from a Standard Schema.
- */
-export type InferOutput<T extends StandardSchema> = T extends StandardSchema<any, infer O> ? O : never;

package/src/static-site-generator/static-site-generator.d.ts

@@ -1,57 +0,0 @@
-import type { EcoPagesAppConfig } from '../internal-types.js';
-import type { StaticRoute } from '../public-types.js';
-import type { RouteRendererFactory } from '../route-renderer/route-renderer.js';
-import type { FSRouter } from '../router/fs-router.js';
-export declare const STATIC_SITE_GENERATOR_ERRORS: {
-    readonly ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy";
-    readonly unsupportedBodyType: (bodyType: string) => string;
-    readonly missingIntegration: (routePath: string) => string;
-    readonly noRendererForIntegration: (integrationName: string) => string;
-    readonly dynamicRouteRequiresStaticPaths: (routePath: string) => string;
-};
-export declare class StaticSiteGenerator {
-    appConfig: EcoPagesAppConfig;
-    constructor({ appConfig }: {
-        appConfig: EcoPagesAppConfig;
-    });
-    generateRobotsTxt(): void;
-    isRootDir(path: string): boolean | null;
-    getDirectories(routes: string[]): string[];
-    /**
-     * Extracts dynamic parameters from the actual path based on the template path.
-     *
-     * @param templatePath - The template path (e.g., "/blog/[slug]")
-     * @param actualPath - The actual path (e.g., "/blog/my-post")
-     * @returns A record of extracted parameters (e.g., { slug: "my-post" })
-     */
-    private extractParams;
-    generateStaticPages(router: FSRouter, baseUrl: string, routeRendererFactory?: RouteRendererFactory): Promise<void>;
-    run({ router, baseUrl, routeRendererFactory, staticRoutes, }: {
-        router: FSRouter;
-        baseUrl: string;
-        routeRendererFactory?: RouteRendererFactory;
-        staticRoutes?: StaticRoute[];
-    }): Promise<void>;
-    /**
-     * Generates static pages from explicit static routes registered via app.static().
-     * These routes use eco.page views via loader functions for HMR support.
-     */
-    private generateExplicitStaticPages;
-    /**
-     * Generate a single static page for a non-dynamic route.
-     */
-    private generateSingleStaticRoute;
-    /**
-     * Generate static pages for a dynamic route using staticPaths.
-     */
-    private generateDynamicStaticRoute;
-    /**
-     * Resolve a route path template with actual params.
-     * Supports both :param and [param] syntax.
-     */
-    private resolveRoutePath;
-    /**
-     * Get the output file path for a given route.
-     */
-    private getOutputPath;
-}

package/src/static-site-generator/static-site-generator.js

@@ -1,272 +0,0 @@
-import path from "node:path";
-import { appLogger } from "../global/app-logger.js";
-import { fileSystem } from "@ecopages/file-system";
-import { PathUtils } from "../utils/path-utils.module.js";
-const STATIC_SITE_GENERATOR_ERRORS = {
-  ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy",
-  unsupportedBodyType: (bodyType) => `Unsupported body type for static generation: ${bodyType}`,
-  missingIntegration: (routePath) => `View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page().`,
-  noRendererForIntegration: (integrationName) => `No renderer found for integration: ${integrationName}`,
-  dynamicRouteRequiresStaticPaths: (routePath) => `Dynamic route ${routePath} requires staticPaths to be defined on the view.`
-};
-class StaticSiteGenerator {
-  appConfig;
-  constructor({ appConfig }) {
-    this.appConfig = appConfig;
-  }
-  generateRobotsTxt() {
-    let data = "";
-    const preferences = this.appConfig.robotsTxt.preferences;
-    for (const userAgent in preferences) {
-      data += `user-agent: ${userAgent}
-`;
-      for (const path2 of preferences[userAgent]) {
-        data += `disallow: ${path2}
-`;
-      }
-      data += "\n";
-    }
-    fileSystem.ensureDir(this.appConfig.distDir);
-    fileSystem.write(`${this.appConfig.distDir}/robots.txt`, data);
-  }
-  isRootDir(path2) {
-    const slashes = path2.match(/\//g);
-    return slashes && slashes.length === 1;
-  }
-  getDirectories(routes) {
-    const directories = /* @__PURE__ */ new Set();
-    for (const route of routes) {
-      const path2 = route.startsWith("http") ? new URL(route).pathname : route;
-      const segments = path2.split("/");
-      if (segments.length > 2) {
-        directories.add(segments.slice(0, segments.length - 1).join("/"));
-      }
-    }
-    return Array.from(directories);
-  }
-  /**
-   * Extracts dynamic parameters from the actual path based on the template path.
-   *
-   * @param templatePath - The template path (e.g., "/blog/[slug]")
-   * @param actualPath - The actual path (e.g., "/blog/my-post")
-   * @returns A record of extracted parameters (e.g., { slug: "my-post" })
-   */
-  extractParams(templatePath, actualPath) {
-    const templateSegments = templateSegmentsFromPath(templatePath);
-    const actualSegments = templateSegmentsFromPath(actualPath);
-    const params = {};
-    for (let i = 0; i < templateSegments.length; i++) {
-      const segment = templateSegments[i];
-      if (segment.startsWith("[") && segment.endsWith("]")) {
-        const paramName = segment.slice(1, -1).replace("...", "");
-        params[paramName] = actualSegments[i];
-      }
-    }
-    return params;
-  }
-  async generateStaticPages(router, baseUrl, routeRendererFactory) {
-    const routes = Object.keys(router.routes).filter((route) => !route.includes("["));
-    appLogger.debug("Static Pages", routes);
-    const directories = this.getDirectories(routes);
-    for (const directory of directories) {
-      fileSystem.ensureDir(path.join(this.appConfig.rootDir, this.appConfig.distDir, directory));
-    }
-    for (const route of routes) {
-      try {
-        const { filePath, pathname: routePathname } = router.routes[route];
-        const ext = PathUtils.getEcoTemplateExtension(filePath);
-        const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
-        const strategy = integration?.staticBuildStep || "render";
-        let contents;
-        if (strategy === "fetch") {
-          const fetchUrl = route.startsWith("http") ? route : `${baseUrl}${route}`;
-          const response = await fetch(fetchUrl);
-          if (!response.ok) {
-            appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
-            continue;
-          }
-          contents = await response.text();
-        } else {
-          if (!routeRendererFactory) {
-            throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
-          }
-          let pathname2 = routePathname;
-          const pathnameSegments2 = pathname2.split("/").filter(Boolean);
-          if (pathname2 === "/") {
-            pathname2 = "/index.html";
-          } else if (pathnameSegments2.join("/").includes("[")) {
-            pathname2 = `${route.replace(router.origin, "")}.html`;
-          } else if (pathnameSegments2.length >= 1 && directories.includes(`/${pathnameSegments2.join("/")}`)) {
-            pathname2 = `${pathname2.endsWith("/") ? pathname2 : `${pathname2}/`}index.html`;
-          } else {
-            pathname2 += ".html";
-          }
-          const renderer = routeRendererFactory.createRenderer(filePath);
-          const params = this.extractParams(routePathname, pathname2.replace(".html", ""));
-          const result = await renderer.createRoute({
-            file: filePath,
-            params
-          });
-          const body = result.body;
-          if (typeof body === "string" || Buffer.isBuffer(body)) {
-            contents = body;
-          } else if (body instanceof ReadableStream) {
-            contents = await new Response(body).text();
-          } else {
-            throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
-          }
-        }
-        let pathname = routePathname;
-        const pathnameSegments = pathname.split("/").filter(Boolean);
-        if (pathname === "/") {
-          pathname = "/index.html";
-        } else if (pathnameSegments.join("/").includes("[")) {
-          pathname = `${route.replace(router.origin, "")}.html`;
-        } else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join("/")}`)) {
-          pathname = `${pathname.endsWith("/") ? pathname : `${pathname}/`}index.html`;
-        } else {
-          pathname += ".html";
-        }
-        const outputPath = path.join(this.appConfig.rootDir, this.appConfig.distDir, pathname);
-        fileSystem.write(outputPath, contents);
-      } catch (error) {
-        appLogger.error(
-          `Error generating static page for ${route}:`,
-          error instanceof Error ? error : String(error)
-        );
-      }
-    }
-  }
-  async run({
-    router,
-    baseUrl,
-    routeRendererFactory,
-    staticRoutes
-  }) {
-    this.generateRobotsTxt();
-    await this.generateStaticPages(router, baseUrl, routeRendererFactory);
-    if (staticRoutes && staticRoutes.length > 0 && routeRendererFactory) {
-      await this.generateExplicitStaticPages(staticRoutes, routeRendererFactory);
-    }
-  }
-  /**
-   * Generates static pages from explicit static routes registered via app.static().
-   * These routes use eco.page views via loader functions for HMR support.
-   */
-  async generateExplicitStaticPages(staticRoutes, routeRendererFactory) {
-    appLogger.debug(
-      "Generating explicit static routes",
-      staticRoutes.map((r) => r.path)
-    );
-    for (const route of staticRoutes) {
-      try {
-        const mod = await route.loader();
-        const view = mod.default;
-        const isDynamic = route.path.includes(":") || route.path.includes("[");
-        if (isDynamic) {
-          await this.generateDynamicStaticRoute(route.path, view, routeRendererFactory);
-        } else {
-          await this.generateSingleStaticRoute(route.path, view, routeRendererFactory);
-        }
-      } catch (error) {
-        appLogger.error(
-          `Error generating explicit static page for ${route.path}:`,
-          error instanceof Error ? error : String(error)
-        );
-      }
-    }
-  }
-  /**
-   * Generate a single static page for a non-dynamic route.
-   */
-  async generateSingleStaticRoute(routePath, view, routeRendererFactory) {
-    const integrationName = view.config?.__eco?.integration;
-    if (!integrationName) {
-      throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
-    }
-    const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
-    if (!renderer) {
-      throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
-    }
-    const props = view.staticProps ? (await view.staticProps({
-      pathname: { params: {} },
-      appConfig: this.appConfig,
-      runtimeOrigin: this.appConfig.baseUrl
-    })).props : {};
-    const response = await renderer.renderToResponse(view, props, {});
-    const contents = await response.text();
-    const outputPath = this.getOutputPath(routePath);
-    fileSystem.ensureDir(path.dirname(outputPath));
-    fileSystem.write(outputPath, contents);
-    appLogger.debug(`Generated static page: ${routePath} -> ${outputPath}`);
-  }
-  /**
-   * Generate static pages for a dynamic route using staticPaths.
-   */
-  async generateDynamicStaticRoute(routePath, view, routeRendererFactory) {
-    if (!view.staticPaths) {
-      throw new Error(STATIC_SITE_GENERATOR_ERRORS.dynamicRouteRequiresStaticPaths(routePath));
-    }
-    const integrationName = view.config?.__eco?.integration;
-    if (!integrationName) {
-      throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
-    }
-    const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
-    if (!renderer) {
-      throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
-    }
-    const { paths } = await view.staticPaths({
-      appConfig: this.appConfig,
-      runtimeOrigin: this.appConfig.baseUrl
-    });
-    for (const { params } of paths) {
-      const resolvedPath = this.resolveRoutePath(routePath, params);
-      const props = view.staticProps ? (await view.staticProps({
-        pathname: { params },
-        appConfig: this.appConfig,
-        runtimeOrigin: this.appConfig.baseUrl
-      })).props : {};
-      const response = await renderer.renderToResponse(view, props, {});
-      const contents = await response.text();
-      const outputPath = this.getOutputPath(resolvedPath);
-      fileSystem.ensureDir(path.dirname(outputPath));
-      fileSystem.write(outputPath, contents);
-      appLogger.debug(`Generated static page: ${resolvedPath} -> ${outputPath}`);
-    }
-  }
-  /**
-   * Resolve a route path template with actual params.
-   * Supports both :param and [param] syntax.
-   */
-  resolveRoutePath(routePath, params) {
-    let resolved = routePath;
-    for (const [key, value] of Object.entries(params)) {
-      const paramValue = Array.isArray(value) ? value.join("/") : value;
-      resolved = resolved.replace(`:${key}`, paramValue);
-      resolved = resolved.replace(`[${key}]`, paramValue);
-      resolved = resolved.replace(`[...${key}]`, paramValue);
-    }
-    return resolved;
-  }
-  /**
-   * Get the output file path for a given route.
-   */
-  getOutputPath(routePath) {
-    let outputName;
-    if (routePath === "/") {
-      outputName = "index.html";
-    } else if (routePath.endsWith("/")) {
-      outputName = `${routePath}index.html`;
-    } else {
-      outputName = `${routePath}.html`;
-    }
-    return path.join(this.appConfig.rootDir, this.appConfig.distDir, outputName);
-  }
-}
-function templateSegmentsFromPath(path2) {
-  return path2.split("/").filter(Boolean);
-}
-export {
-  STATIC_SITE_GENERATOR_ERRORS,
-  StaticSiteGenerator
-};

package/src/utils/css.d.ts

@@ -1 +0,0 @@
-export declare const css: (strings: TemplateStringsArray, ...values: any[]) => Promise<string>;

package/src/utils/css.js

@@ -1,7 +0,0 @@
-const css = async (strings, ...values) => {
-  const css2 = strings.reduce((acc, str, i) => acc + str + (values[i] || ""), "");
-  return css2;
-};
-export {
-  css
-};

package/src/utils/deep-merge.d.ts

@@ -1,14 +0,0 @@
-/**
- * This module contains a simple utility function to merge two objects deeply
- * @module
- */
-/**
- * Deeply merges two objects or arrays
- * @function deepMerge
- * @template T - Type of target object
- * @template U - Type of source object
- * @param target - The target object to merge into
- * @param source - The source object to merge from
- * @returns A new object with merged properties
- */
-export declare function deepMerge<T, U>(target: T, source: U): T & U;

package/src/utils/deep-merge.js

@@ -1,32 +0,0 @@
-function isObject(item) {
-  return item && typeof item === "object" && !Array.isArray(item);
-}
-function isArray(item) {
-  return Array.isArray(item);
-}
-function deepMerge(target, source) {
-  if (isArray(target) && isArray(source)) {
-    return [...target, ...source];
-  }
-  if (!isObject(target) || !isObject(source)) {
-    return source;
-  }
-  const output = Object.assign({}, target);
-  for (const key in source) {
-    if (isObject(source[key])) {
-      if (!target[key]) {
-        Object.assign(output, { [key]: source[key] });
-      } else {
-        output[key] = deepMerge(target[key], source[key]);
-      }
-    } else if (isArray(source[key])) {
-      output[key] = [...target[key] || [], ...source[key]];
-    } else if (source[key] !== void 0) {
-      Object.assign(output, { [key]: source[key] });
-    }
-  }
-  return output;
-}
-export {
-  deepMerge
-};

package/src/utils/hash.d.ts

@@ -1 +0,0 @@
-export declare const rapidhash: (content: string | Buffer<ArrayBufferLike>) => number | bigint;

package/src/utils/hash.js

@@ -1,7 +0,0 @@
-import { runtimeHash } from "./runtime.js";
-const rapidhash = (content) => {
-  return runtimeHash(content);
-};
-export {
-  rapidhash
-};