@ecopages/core 0.2.0-alpha.3 → 0.2.0-alpha.31

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

@@ -1,204 +0,0 @@
-import type { StandardSchema, StandardSchemaIssue } from './validation/standard-schema.types.ts';
-
-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.ts';
- *
- * 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: ValidationSource,
-		schemas: ValidationSchemas,
-	): Promise<ValidationResult<ValidatedData>> {
-		const validated: ValidatedData = {};
-		const allErrors: Array<{ message: string; path?: Array<string | number> }> = [];
-
-		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 };
-	}
-
-	/**
-	 * 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 async validateWithSchema<T>(schema: StandardSchema, data: unknown): Promise<ValidationResult<T>> {
-		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: StandardSchemaIssue) => ({
-						message: issue.message,
-						path: issue.path?.map((p) => (typeof p === 'object' && 'key' in p ? p.key : p)) as
-							| Array<string | number>
-							| undefined,
-					})),
-				};
-			}
-
-			return { success: true, data: result.value as T };
-		} catch (error) {
-			return {
-				success: false,
-				errors: [
-					{
-						message: error instanceof Error ? error.message : 'Validation failed',
-					},
-				],
-			};
-		}
-	}
-}

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

@@ -1,68 +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.ts

@@ -1,359 +0,0 @@
-import path from 'node:path';
-import { appLogger } from '../global/app-logger.ts';
-import type { EcoPagesAppConfig } from '../internal-types.ts';
-import type { EcoPageComponent, StaticRoute } from '../public-types.ts';
-import type { RouteRendererFactory } from '../route-renderer/route-renderer.ts';
-import type { FSRouter } from '../router/fs-router.ts';
-import { fileSystem } from '@ecopages/file-system';
-import { PathUtils } from '../utils/path-utils.module.ts';
-
-export const STATIC_SITE_GENERATOR_ERRORS = {
-	ROUTE_RENDERER_FACTORY_REQUIRED: 'RouteRendererFactory is required for render strategy',
-	unsupportedBodyType: (bodyType: string) => `Unsupported body type for static generation: ${bodyType}`,
-	missingIntegration: (routePath: string) =>
-		`View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page().`,
-	noRendererForIntegration: (integrationName: string) => `No renderer found for integration: ${integrationName}`,
-	dynamicRouteRequiresStaticPaths: (routePath: string) =>
-		`Dynamic route ${routePath} requires staticPaths to be defined on the view.`,
-} as const;
-
-export class StaticSiteGenerator {
-	appConfig: EcoPagesAppConfig;
-
-	constructor({ appConfig }: { appConfig: EcoPagesAppConfig }) {
-		this.appConfig = appConfig;
-	}
-
-	generateRobotsTxt(): void {
-		let data = '';
-		const preferences = this.appConfig.robotsTxt.preferences;
-
-		for (const userAgent in preferences) {
-			data += `user-agent: ${userAgent}\n`;
-			for (const path of preferences[userAgent]) {
-				data += `disallow: ${path}\n`;
-			}
-			data += '\n';
-		}
-
-		fileSystem.ensureDir(this.appConfig.distDir);
-		fileSystem.write(`${this.appConfig.distDir}/robots.txt`, data);
-	}
-
-	isRootDir(path: string) {
-		const slashes = path.match(/\//g);
-		return slashes && slashes.length === 1;
-	}
-
-	getDirectories(routes: string[]) {
-		const directories = new Set<string>();
-
-		for (const route of routes) {
-			const path = route.startsWith('http') ? new URL(route).pathname : route;
-
-			const segments = path.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" })
-	 */
-	private extractParams(templatePath: string, actualPath: string): Record<string, string> {
-		const templateSegments = templateSegmentsFromPath(templatePath);
-		const actualSegments = templateSegmentsFromPath(actualPath);
-		const params: Record<string, string> = {};
-
-		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: FSRouter, baseUrl: string, routeRendererFactory?: 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: string | Buffer;
-
-				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 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 renderer = routeRendererFactory.createRenderer(filePath);
-					const params = this.extractParams(routePathname, pathname.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,
-	}: {
-		router: FSRouter;
-		baseUrl: string;
-		routeRendererFactory?: RouteRendererFactory;
-		staticRoutes?: StaticRoute[];
-	}) {
-		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.
-	 */
-	private async generateExplicitStaticPages(
-		staticRoutes: StaticRoute[],
-		routeRendererFactory: RouteRendererFactory,
-	): Promise<void> {
-		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.
-	 */
-	private async generateSingleStaticRoute(
-		routePath: string,
-		view: EcoPageComponent<any>,
-		routeRendererFactory: RouteRendererFactory,
-	): Promise<void> {
-		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.
-	 */
-	private async generateDynamicStaticRoute(
-		routePath: string,
-		view: EcoPageComponent<any>,
-		routeRendererFactory: RouteRendererFactory,
-	): Promise<void> {
-		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.
-	 */
-	private resolveRoutePath(routePath: string, params: Record<string, string | string[]>): string {
-		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.
-	 */
-	private getOutputPath(routePath: string): string {
-		let outputName: string;
-
-		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);
-	}
-}
-
-/**
- * Splits a path into segments, filtering out empty strings.
- */
-function templateSegmentsFromPath(path: string) {
-	return path.split('/').filter(Boolean);
-}

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/css.ts

@@ -1,5 +0,0 @@
-export const css = async (strings: TemplateStringsArray, ...values: any[]): Promise<string> => {
-	const css = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
-	// return await PostCssProcessor.processStringOrBuffer(css);
-	return css;
-};

package/src/utils/deep-merge.ts

@@ -1,47 +0,0 @@
-/**
- * This module contains a simple utility function to merge two objects deeply
- * @module
- */
-
-function isObject(item: any): item is Record<string, unknown> {
-	return item && typeof item === 'object' && !Array.isArray(item);
-}
-
-function isArray(item: any): item is unknown[] {
-	return Array.isArray(item);
-}
-
-/**
- * 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 function deepMerge<T, U>(target: T, source: U): T & U {
-	if (isArray(target) && isArray(source)) {
-		return [...target, ...source] as T & U;
-	}
-
-	if (!isObject(target) || !isObject(source)) {
-		return source as T & U;
-	}
-
-	const output = Object.assign({}, target) as T & U;
-	for (const key in source) {
-		if (isObject((source as any)[key])) {
-			if (!(target as any)[key]) {
-				Object.assign(output as object, { [key]: (source as any)[key] });
-			} else {
-				output[key as keyof T] = deepMerge((target as any)[key], (source as any)[key]);
-			}
-		} else if (isArray((source as any)[key])) {
-			output[key as keyof T] = [...((target as any)[key] || []), ...(source as any)[key]] as (T & U)[keyof T];
-		} else if ((source as any)[key] !== undefined) {
-			Object.assign(output as object, { [key]: (source as any)[key] });
-		}
-	}
-	return output;
-}

package/src/utils/hash.ts

@@ -1,5 +0,0 @@
-import { runtimeHash } from './runtime.ts';
-
-export const rapidhash = (content: string | Buffer<ArrayBufferLike>): number | bigint => {
-	return runtimeHash(content);
-};

package/src/utils/html.ts

@@ -1 +0,0 @@
-export { html } from 'ghtml';