@ecopages/core 0.2.0-beta.30 → 0.2.0-beta.32

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

@@ -1,100 +1,162 @@
-import { SchemaError, validateStandardSchema } from "./validate-standard-schema.js";
-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;
-      }
+import { SchemaError, validateStandardSchema } from './validate-standard-schema.js';
+/**
+ * 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 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 !== undefined) {
+            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 };
     }
-    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.
-   */
-  mapSchemaIssue(issue) {
-    return {
-      message: issue.message,
-      path: issue.path?.map((p) => typeof p === "object" && "key" in p ? p.key : p)
-    };
-  }
-  async validateWithSchema(schema, data) {
-    try {
-      const value = await validateStandardSchema(schema, data);
-      return { success: true, data: value };
-    } catch (error) {
-      if (error instanceof SchemaError) {
+    /**
+     * Validates a single value against a Standard Schema.
+     */
+    mapSchemaIssue(issue) {
         return {
-          success: false,
-          errors: error.issues.map((issue) => this.mapSchemaIssue(issue))
+            message: issue.message,
+            path: issue.path?.map((p) => (typeof p === 'object' && 'key' in p ? p.key : p)),
         };
-      }
-      return {
-        success: false,
-        errors: [
-          {
-            message: error instanceof Error ? error.message : "Validation failed"
-          }
-        ]
-      };
     }
-  }
+    async validateWithSchema(schema, data) {
+        try {
+            const value = await validateStandardSchema(schema, data);
+            return { success: true, data: value };
+        }
+        catch (error) {
+            if (error instanceof SchemaError) {
+                return {
+                    success: false,
+                    errors: error.issues.map((issue) => this.mapSchemaIssue(issue)),
+                };
+            }
+            return {
+                success: false,
+                errors: [
+                    {
+                        message: error instanceof Error ? error.message : 'Validation failed',
+                    },
+                ],
+            };
+        }
+    }
 }
-export {
-  SchemaValidationService
-};

package/src/services/validation/standard-schema.types.js

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

package/src/services/validation/validate-standard-schema.js

@@ -1,14 +1,14 @@
-import { SchemaError } from "@standard-schema/utils";
-import { SchemaError as SchemaError2 } from "@standard-schema/utils";
-async function validateStandardSchema(schema, value) {
-  const resultOrPromise = schema["~standard"].validate(value);
-  const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
-  if (result.issues) {
-    throw new SchemaError(result.issues);
-  }
-  return result.value;
+import { SchemaError } from '@standard-schema/utils';
+export { SchemaError } from '@standard-schema/utils';
+/**
+ * Validates a value with any Standard Schema-compliant validator.
+ * Throws {@link SchemaError} when validation fails.
+ */
+export async function validateStandardSchema(schema, value) {
+    const resultOrPromise = schema['~standard'].validate(value);
+    const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
+    if (result.issues) {
+        throw new SchemaError(result.issues);
+    }
+    return result.value;
 }
-export {
-  SchemaError2 as SchemaError,
-  validateStandardSchema
-};

package/src/static-site-generator/production-page-browser-graph-prebuild.js

@@ -1,22 +1,38 @@
-import path from "node:path";
-import { getAppPageBrowserGraphSession } from "../route-renderer/orchestration/page-browser-graph/page-browser-graph-session.js";
-function shouldPrebuildProductionPageBrowserGraphs() {
-  return process.env.NODE_ENV === "production";
+import path from 'node:path';
+import { getAppPageBrowserGraphSession } from '../route-renderer/orchestration/page-browser-graph/page-browser-graph-session.js';
+/**
+ * Returns whether production static export should warm Page Browser Graphs before rendering.
+ *
+ * @remarks
+ * True only when `NODE_ENV === 'production'`. Independent of `force` and of
+ * unified pages-graph env flags. Does not persist a disk manifest.
+ */
+export function shouldPrebuildProductionPageBrowserGraphs() {
+    return process.env.NODE_ENV === 'production';
 }
-function clearProductionPageBrowserGraphSession(appConfig) {
-  getAppPageBrowserGraphSession(appConfig).clearPolicyRecords("production");
+/**
+ * Clears in-memory production Page Browser Graph session records.
+ *
+ * @remarks
+ * Clears only the `'production'` policy so a failed or force export cannot
+ * reuse staged graph output. Development session records are left intact.
+ */
+export function clearProductionPageBrowserGraphSession(appConfig) {
+    getAppPageBrowserGraphSession(appConfig).clearPolicyRecords('production');
 }
-async function prebuildProductionPageBrowserGraphs(routeFiles, routeRendererFactory) {
-  const uniqueRouteFiles = [...new Set(routeFiles.map((routeFile) => path.resolve(routeFile)))].sort(
-    (left, right) => left.localeCompare(right)
-  );
-  for (const routeFile of uniqueRouteFiles) {
-    const renderer = routeRendererFactory.getPageRenderer(routeFile);
-    await renderer.prebuildProductionPageBrowserGraph(routeFile);
-  }
+/**
+ * Warms production Page Browser Graphs for the supplied static route files.
+ *
+ * @remarks
+ * Deduplicates and lexicographically sorts absolute route paths, then calls
+ * each integration renderer's `prebuildProductionPageBrowserGraph` sequentially
+ * (activates integration runtime, then resolves into
+ * `page-browser-graph-session`). Does not persist a disk manifest.
+ */
+export async function prebuildProductionPageBrowserGraphs(routeFiles, routeRendererFactory) {
+    const uniqueRouteFiles = [...new Set(routeFiles.map((routeFile) => path.resolve(routeFile)))].sort((left, right) => left.localeCompare(right));
+    for (const routeFile of uniqueRouteFiles) {
+        const renderer = routeRendererFactory.getPageRenderer(routeFile);
+        await renderer.prebuildProductionPageBrowserGraph(routeFile);
+    }
 }
-export {
-  clearProductionPageBrowserGraphSession,
-  prebuildProductionPageBrowserGraphs,
-  shouldPrebuildProductionPageBrowserGraphs
-};

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

@@ -1,31 +1,36 @@
-import { matchesAnyPathPattern, normalizePathname } from "../utils/path-pattern.js";
-import { buildSitemapLocation } from "./sitemap.js";
-function resolveSitemapLocations(input) {
-  const exclude = input.sitemap.exclude ?? [];
-  const locations = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const pathname of input.eligiblePathnames) {
-    const normalized = normalizePathname(pathname);
-    if (matchesAnyPathPattern(normalized, exclude)) {
-      continue;
+import { matchesAnyPathPattern, normalizePathname } from '../utils/path-pattern.js';
+import { buildSitemapLocation } from './sitemap.js';
+/**
+ * Builds the ordered absolute locations for sitemap.xml.
+ *
+ * @remarks
+ * `eligiblePathnames` must already be successfully exported and robots-indexable.
+ * Filtering here is only `sitemap.exclude`, then `extraUrls` are appended.
+ * `extraUrls` always include (deduped) and are not subject to `exclude` or page robots.
+ */
+export function resolveSitemapLocations(input) {
+    const exclude = input.sitemap.exclude ?? [];
+    const locations = [];
+    const seen = new Set();
+    for (const pathname of input.eligiblePathnames) {
+        const normalized = normalizePathname(pathname);
+        if (matchesAnyPathPattern(normalized, exclude)) {
+            continue;
+        }
+        const location = buildSitemapLocation(input.baseUrl, normalized);
+        if (seen.has(location)) {
+            continue;
+        }
+        seen.add(location);
+        locations.push(location);
     }
-    const location = buildSitemapLocation(input.baseUrl, normalized);
-    if (seen.has(location)) {
-      continue;
+    for (const extraUrl of input.sitemap.extraUrls ?? []) {
+        const location = buildSitemapLocation(input.baseUrl, extraUrl);
+        if (seen.has(location)) {
+            continue;
+        }
+        seen.add(location);
+        locations.push(location);
     }
-    seen.add(location);
-    locations.push(location);
-  }
-  for (const extraUrl of input.sitemap.extraUrls ?? []) {
-    const location = buildSitemapLocation(input.baseUrl, extraUrl);
-    if (seen.has(location)) {
-      continue;
-    }
-    seen.add(location);
-    locations.push(location);
-  }
-  return locations;
+    return locations;
 }
-export {
-  resolveSitemapLocations
-};

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

@@ -1,33 +1,42 @@
-import { escapeXmlText } from "../utils/html-escaping.js";
-import { normalizePathname } from "../utils/path-pattern.js";
-function buildSitemapLocation(baseUrl, pathnameOrUrl) {
-  const trimmed = pathnameOrUrl.trim();
-  if (/^https?:\/\//i.test(trimmed)) {
-    return normalizeLocation(trimmed);
-  }
-  const origin = baseUrl.replace(/\/+$/, "");
-  const pathname = normalizePathname(trimmed);
-  return pathname === "/" ? `${origin}/` : `${origin}${pathname}`;
+import { escapeXmlText } from '../utils/html-escaping.js';
+import { normalizePathname } from '../utils/path-pattern.js';
+/**
+ * Joins a base origin with a pathname or absolute URL into a sitemap `<loc>` value.
+ *
+ * @remarks
+ * Trailing slashes are stripped except for the site root (`/`). Absolute `http(s)`
+ * URLs in `extraUrls` are returned as-is (still slash-normalized).
+ */
+export function buildSitemapLocation(baseUrl, pathnameOrUrl) {
+    const trimmed = pathnameOrUrl.trim();
+    if (/^https?:\/\//i.test(trimmed)) {
+        return normalizeLocation(trimmed);
+    }
+    const origin = baseUrl.replace(/\/+$/, '');
+    const pathname = normalizePathname(trimmed);
+    return pathname === '/' ? `${origin}/` : `${origin}${pathname}`;
 }
-function renderSitemap(locations) {
-  const urls = locations.map((loc) => `  <url>
-    <loc>${escapeXmlText(normalizeLocation(loc))}</loc>
-  </url>`).join("\n");
-  return [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
-    urls,
-    "</urlset>",
-    ""
-  ].join("\n");
+/**
+ * Renders a sitemap.org 0.9 urlset document from absolute location URLs.
+ *
+ * @remarks
+ * Callers are responsible for deduplication; this serializer preserves input order.
+ */
+export function renderSitemap(locations) {
+    const urls = locations
+        .map((loc) => `  <url>\n    <loc>${escapeXmlText(normalizeLocation(loc))}</loc>\n  </url>`)
+        .join('\n');
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        urls,
+        '</urlset>',
+        '',
+    ].join('\n');
 }
 function normalizeLocation(location) {
-  if (/^https?:\/\/[^/]+\/?$/i.test(location)) {
-    return `${location.replace(/\/+$/, "")}/`;
-  }
-  return location.replace(/\/+$/, "");
+    if (/^https?:\/\/[^/]+\/?$/i.test(location)) {
+        return `${location.replace(/\/+$/, '')}/`;
+    }
+    return location.replace(/\/+$/, '');
 }
-export {
-  buildSitemapLocation,
-  renderSitemap
-};

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

@@ -1,59 +1,37 @@
-import {
-  createBuildInputsFingerprint,
-  hashAppConfigFile,
-  haveBuildInputsChanged
-} from "../build/cache/build-input-fingerprint.js";
-import { clearPersistedProductionBuildCacheManifests } from "../build/cache/production-build-cache.js";
-import {} from "../services/module-loading/route-module-build-manifest.js";
-import {
-  getSharedRouteModuleBuildCache,
-  getServerModuleBuildCacheOutdir
-} from "../services/module-loading/route-module-build-cache-registry.js";
-import {
-  collectBuildInputContributors,
-  createBuildInputsFingerprint as createBuildInputsFingerprint2,
-  didBuildInputContributorChange,
-  hashAppConfigFile as hashAppConfigFile2,
-  haveBuildInputsChanged as haveBuildInputsChanged2
-} from "../build/cache/build-input-fingerprint.js";
-function createRouteModuleStaticRenderCacheContext(appConfig) {
-  return {
-    configHash: hashAppConfigFile(appConfig),
-    buildInputsFingerprint: createBuildInputsFingerprint(appConfig)
-  };
+import { createBuildInputsFingerprint, hashAppConfigFile, haveBuildInputsChanged, } from '../build/cache/build-input-fingerprint.js';
+import { clearPersistedProductionBuildCacheManifests } from '../build/cache/production-build-cache.js';
+import {} from '../services/module-loading/route-module-build-manifest.js';
+import { getSharedRouteModuleBuildCache, getServerModuleBuildCacheOutdir, } from '../services/module-loading/route-module-build-cache-registry.js';
+export { collectBuildInputContributors, createBuildInputsFingerprint, didBuildInputContributorChange, hashAppConfigFile, haveBuildInputsChanged, } from '../build/cache/build-input-fingerprint.js';
+/** Builds the static-render invalidation context for one app config. */
+export function createRouteModuleStaticRenderCacheContext(appConfig) {
+    return {
+        configHash: hashAppConfigFile(appConfig),
+        buildInputsFingerprint: createBuildInputsFingerprint(appConfig),
+    };
 }
-function shouldResetStaticExportDirectory(appConfig, force = false) {
-  if (force) {
-    return true;
-  }
-  if (haveBuildInputsChanged(appConfig)) {
-    return true;
-  }
-  const routeModuleCache = getSharedRouteModuleBuildCache(getServerModuleBuildCacheOutdir(appConfig), appConfig);
-  return !routeModuleCache.isIncrementalStaticGenerationAvailable(
-    createRouteModuleStaticRenderCacheContext(appConfig)
-  );
+/** Returns whether `dist/` should be wiped before the next static export. */
+export function shouldResetStaticExportDirectory(appConfig, force = false) {
+    if (force) {
+        return true;
+    }
+    if (haveBuildInputsChanged(appConfig)) {
+        return true;
+    }
+    const routeModuleCache = getSharedRouteModuleBuildCache(getServerModuleBuildCacheOutdir(appConfig), appConfig);
+    return !routeModuleCache.isIncrementalStaticGenerationAvailable(createRouteModuleStaticRenderCacheContext(appConfig));
 }
-function clearProductionBuildCaches(appConfig) {
-  if (process.env.NODE_ENV !== "production") {
-    return;
-  }
-  clearPersistedProductionBuildCacheManifests(appConfig);
-  for (const cache of appConfig.runtime?.routeModuleBuildCaches?.values() ?? []) {
-    cache.resetMemory();
-  }
-  appConfig.runtime?.routeModuleBuildCaches?.clear();
-  if (appConfig.runtime) {
-    appConfig.runtime.buildRuntime = void 0;
-  }
+/** Removes persisted production build caches so the next build recomputes everything. */
+export function clearProductionBuildCaches(appConfig) {
+    if (process.env.NODE_ENV !== 'production') {
+        return;
+    }
+    clearPersistedProductionBuildCacheManifests(appConfig);
+    for (const cache of appConfig.runtime?.routeModuleBuildCaches?.values() ?? []) {
+        cache.resetMemory();
+    }
+    appConfig.runtime?.routeModuleBuildCaches?.clear();
+    if (appConfig.runtime) {
+        appConfig.runtime.buildRuntime = undefined;
+    }
 }
-export {
-  clearProductionBuildCaches,
-  collectBuildInputContributors,
-  createBuildInputsFingerprint2 as createBuildInputsFingerprint,
-  createRouteModuleStaticRenderCacheContext,
-  didBuildInputContributorChange,
-  hashAppConfigFile2 as hashAppConfigFile,
-  haveBuildInputsChanged2 as haveBuildInputsChanged,
-  shouldResetStaticExportDirectory
-};

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

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