@ecopages/core 0.2.0-alpha.53 → 0.2.0-alpha.54

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

@@ -0,0 +1,204 @@
+import type { StandardSchema, StandardSchemaIssue } from './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.d.ts → standard-schema.types.ts}

@@ -22,43 +22,46 @@
  * ```
  */
 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;
-        };
-    };
+	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;
+	readonly value: Output;
+	readonly issues?: undefined;
 }
+
 /**
  * Failed validation result.
  */
 export interface StandardSchemaFailureResult {
-    readonly value?: undefined;
-    readonly issues: ReadonlyArray<StandardSchemaIssue>;
+	readonly value?: undefined;
+	readonly issues: ReadonlyArray<StandardSchemaIssue>;
 }
+
 /**
  * Validation issue details.
  */
 export interface StandardSchemaIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        key: PropertyKey;
-    }>;
+	readonly message: string;
+	readonly path?: ReadonlyArray<PropertyKey | { key: PropertyKey }>;
 }
+
 /**
  * Infers the output type from a Standard Schema.
  */

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

@@ -0,0 +1,408 @@
+import { describe, expect, test, beforeEach, afterEach, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
+import { StaticSiteGenerator } from './static-site-generator';
+import type { EcoPagesAppConfig } from '../types/internal-types';
+import { appLogger } from '../global/app-logger.ts';
+import { DEFAULT_ECOPAGES_WORK_DIR } from '../config/constants.ts';
+
+const originalEnsureDir = fileSystem.ensureDir;
+const originalWrite = fileSystem.write;
+
+const createMockConfig = (overrides: Partial<EcoPagesAppConfig> = {}): EcoPagesAppConfig =>
+	({
+		rootDir: '/test/project',
+		distDir: 'dist',
+		workDir: DEFAULT_ECOPAGES_WORK_DIR,
+		srcDir: 'src',
+		robotsTxt: {
+			preferences: {
+				'*': ['/admin', '/private'],
+				Googlebot: ['/no-google'],
+			},
+		},
+		absolutePaths: {
+			distDir: '/test/project/dist',
+			workDir: '/test/project/.eco',
+		} as EcoPagesAppConfig['absolutePaths'],
+		integrations: [],
+		...overrides,
+	}) as EcoPagesAppConfig;
+
+const testInjectedMeta = {
+	id: 'test-page',
+	file: '/src/pages/test.tsx',
+	integration: 'test',
+};
+
+type StaticGenerationRouteSource = Parameters<StaticSiteGenerator['generateStaticPages']>[0];
+type StaticPageRouteRendererFactory = NonNullable<Parameters<StaticSiteGenerator['generateStaticPages']>[2]>;
+type StaticGenerationRendererFactory = NonNullable<Parameters<StaticSiteGenerator['run']>[0]['routeRendererFactory']>;
+type StaticGenerationRunnerInput = Parameters<StaticSiteGenerator['run']>[0];
+
+describe('StaticSiteGenerator', () => {
+	let ensureDirMock: any;
+	let writeMock: any;
+
+	beforeEach(() => {
+		ensureDirMock = vi.fn(() => {});
+		writeMock = vi.fn(() => {});
+		fileSystem.ensureDir = ensureDirMock;
+		fileSystem.write = writeMock;
+		vi.spyOn(appLogger, 'warn').mockReturnValue(appLogger);
+	});
+
+	afterEach(() => {
+		fileSystem.ensureDir = originalEnsureDir;
+		fileSystem.write = originalWrite;
+		vi.restoreAllMocks();
+	});
+
+	describe('constructor', () => {
+		test('should create instance with appConfig', () => {
+			const config = createMockConfig();
+			const ssg = new StaticSiteGenerator({ appConfig: config });
+			expect(ssg.appConfig).toBe(config);
+		});
+	});
+
+	describe('isRootDir', () => {
+		test('should return true for root path /', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			expect(ssg.isRootDir('/')).toBe(true);
+		});
+
+		test('should return false for nested path /foo/bar', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			expect(ssg.isRootDir('/foo/bar')).toBe(false);
+		});
+
+		test('should return false for deeply nested paths', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			expect(ssg.isRootDir('/a/b/c/d')).toBe(false);
+		});
+
+		test('should return null (falsy) for paths without slashes', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			expect(ssg.isRootDir('no-slashes')).toBeFalsy();
+		});
+	});
+
+	describe('getDirectories', () => {
+		test('should return empty array for root-level routes', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const dirs = ssg.getDirectories(['/about', '/contact']);
+			expect(dirs).toEqual([]);
+		});
+
+		test('should extract directories from nested routes', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const dirs = ssg.getDirectories(['/blog/post-1', '/blog/post-2', '/docs/api']);
+			expect(dirs).toContain('/blog');
+			expect(dirs).toContain('/docs');
+		});
+
+		test('should handle HTTP URLs and extract pathname', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const dirs = ssg.getDirectories(['http://localhost:3000/blog/post']);
+			expect(dirs).toContain('/blog');
+		});
+
+		test('should deduplicate directories', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const dirs = ssg.getDirectories(['/blog/a', '/blog/b', '/blog/c']);
+			expect(dirs.filter((d) => d === '/blog').length).toBe(1);
+		});
+
+		test('should handle deeply nested paths', () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const dirs = ssg.getDirectories(['/a/b/c/page']);
+			expect(dirs).toContain('/a/b/c');
+		});
+	});
+
+	describe('generateRobotsTxt', () => {
+		test('should generate robots.txt with preferences from config', () => {
+			const config = createMockConfig();
+			const ssg = new StaticSiteGenerator({ appConfig: config });
+
+			ssg.generateRobotsTxt();
+
+			expect(ensureDirMock).toHaveBeenCalledWith('/test/project/dist');
+			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/robots.txt', expect.any(String));
+
+			const writtenContent = writeMock.mock.calls[0][1] as string;
+			expect(writtenContent).toContain('user-agent: *');
+			expect(writtenContent).toContain('disallow: /admin');
+			expect(writtenContent).toContain('disallow: /private');
+			expect(writtenContent).toContain('user-agent: Googlebot');
+			expect(writtenContent).toContain('disallow: /no-google');
+		});
+
+		test('should handle empty preferences', () => {
+			const config = createMockConfig({
+				robotsTxt: { preferences: {} },
+			});
+			const ssg = new StaticSiteGenerator({ appConfig: config });
+
+			ssg.generateRobotsTxt();
+
+			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/robots.txt', '');
+		});
+	});
+
+	describe('generateStaticPages', () => {
+		const createMockRouter = (routes: Record<string, { filePath: string; pathname: string }>) =>
+			({
+				listStaticGenerationRoutes: vi.fn(async () =>
+					Object.values(routes)
+						.filter((value) => !value.pathname.includes('['))
+						.map((value) => ({
+							requestUrl: `http://localhost:3000${value.pathname}`,
+							pathname: value.pathname,
+							templateRoute: {
+								...value,
+								kind: 'exact' as const,
+								paramNames: [],
+							},
+							params: {},
+						})),
+				),
+			}) satisfies StaticGenerationRouteSource;
+
+		const createStaticPageModule = () => ({
+			default: Object.assign(() => null, { cache: 'static' }),
+		});
+
+		test('should filter out dynamic routes containing [', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/static': { filePath: '/src/pages/static.ghtml.ts', pathname: '/static' },
+				'/dynamic/[id]': { filePath: '/src/pages/dynamic/[id].ghtml.ts', pathname: '/dynamic/[id]' },
+			});
+
+			const RendererFactory = {
+				getPageRenderer: vi.fn(() => ({
+					loadPageModule: vi.fn(async () => createStaticPageModule()),
+					execute: vi.fn(async () => ({ body: '<html>Static</html>' })),
+				})),
+			} satisfies StaticPageRouteRendererFactory;
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
+
+			expect(writeMock).toHaveBeenCalledTimes(1);
+		});
+
+		test('should create directories for nested routes', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/blog/post': { filePath: '/src/pages/blog/post.ghtml.ts', pathname: '/blog/post' },
+			});
+
+			const RendererFactory = {
+				getPageRenderer: vi.fn(() => ({
+					loadPageModule: vi.fn(async () => createStaticPageModule()),
+					execute: vi.fn(async () => ({ body: '<html>Blog Post</html>' })),
+				})),
+			} satisfies StaticPageRouteRendererFactory;
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
+
+			expect(ensureDirMock).toHaveBeenCalled();
+		});
+
+		test('should throw error when routeRendererFactory is missing for render strategy', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/page': { filePath: '/src/pages/page.ghtml.ts', pathname: '/page' },
+			});
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', undefined);
+		});
+
+		test('should write index.html for root path', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/': { filePath: '/src/pages/index.ghtml.ts', pathname: '/' },
+			});
+
+			const RendererFactory = {
+				getPageRenderer: vi.fn(() => ({
+					loadPageModule: vi.fn(async () => createStaticPageModule()),
+					execute: vi.fn(async () => ({ body: '<html>Home</html>' })),
+				})),
+			} satisfies StaticPageRouteRendererFactory;
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
+
+			expect(writeMock).toHaveBeenCalledWith(expect.stringContaining('index.html'), '<html>Home</html>');
+		});
+
+		test('should handle Buffer content from renderer', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/': { filePath: '/src/pages/index.ghtml.ts', pathname: '/' },
+			});
+
+			const bufferContent = Buffer.from('<html>Buffer Content</html>');
+			const RendererFactory = {
+				getPageRenderer: vi.fn(() => ({
+					loadPageModule: vi.fn(async () => createStaticPageModule()),
+					execute: vi.fn(async () => ({ body: bufferContent })),
+				})),
+			} satisfies StaticPageRouteRendererFactory;
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
+
+			expect(writeMock).toHaveBeenCalledWith(expect.stringContaining('index.html'), bufferContent);
+		});
+
+		test('should skip cache dynamic pages during static generation and log a warning', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/dashboard': { filePath: '/src/pages/dashboard.tsx', pathname: '/dashboard' },
+			});
+
+			const execute = vi.fn(async () => ({ body: '<html>Dashboard</html>' }));
+			const loadPageModule = vi.fn(async () => ({
+				default: Object.assign(() => null, { cache: 'dynamic' }),
+			}));
+			const RendererFactory = {
+				getPageRenderer: vi.fn(() => ({
+					execute,
+					loadPageModule,
+				})),
+			} satisfies StaticPageRouteRendererFactory;
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
+
+			expect(RendererFactory.getPageRenderer).toHaveBeenCalledWith('/src/pages/dashboard.tsx');
+			expect(loadPageModule).toHaveBeenCalledWith('/src/pages/dashboard.tsx', {
+				cacheScope: 'static-page-probe',
+			});
+			expect(execute).not.toHaveBeenCalled();
+			expect(writeMock).not.toHaveBeenCalled();
+			expect(appLogger.warn).toHaveBeenCalledWith(
+				"Pages with cache: 'dynamic' are not supported in static generation or preview, so they will be skipped\n",
+				'➤ /src/pages/dashboard.tsx',
+			);
+		});
+	});
+
+	describe('run', () => {
+		test('should call generateRobotsTxt and generateStaticPages', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = {
+				listStaticGenerationRoutes: vi.fn(async () => []),
+			} satisfies StaticGenerationRouteSource;
+
+			await ssg.run({
+				router: Router,
+				baseUrl: 'http://localhost:3000',
+			});
+
+			expect(ensureDirMock).toHaveBeenCalled();
+			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/robots.txt', expect.any(String));
+		});
+
+		test('should skip explicit static routes backed by cache dynamic views', async () => {
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const dynamicView = Object.assign(() => null, { cache: 'dynamic' }) as any;
+
+			await ssg.run({
+				router: {
+					listStaticGenerationRoutes: vi.fn(async () => []),
+				} satisfies StaticGenerationRunnerInput['router'],
+				baseUrl: 'http://localhost:3000',
+				routeRendererFactory: {
+					getPageRenderer: vi.fn(),
+					getExplicitViewRenderer: vi.fn(),
+				} satisfies StaticGenerationRendererFactory,
+				staticRoutes: [
+					{
+						path: '/dashboard',
+						loader: async () => ({ default: dynamicView }),
+					},
+				],
+			});
+
+			expect(appLogger.warn).toHaveBeenCalledWith(
+				"Pages with cache: 'dynamic' are not supported in static generation or preview, so they will be skipped\n",
+				'➤ /dashboard',
+			);
+		});
+
+		test('should render dynamic explicit static routes from staticPaths', async () => {
+			const ssg = new StaticSiteGenerator({
+				appConfig: createMockConfig({ baseUrl: 'http://localhost:3000' } as any),
+			});
+			const renderToResponse = vi.fn(async () => new Response('<html>Post</html>'));
+			const staticProps = vi.fn(async ({ pathname }) => ({
+				props: pathname.params,
+			}));
+
+			await ssg.run({
+				router: {
+					listStaticGenerationRoutes: vi.fn(async () => []),
+				} satisfies StaticGenerationRunnerInput['router'],
+				baseUrl: 'http://localhost:3000',
+				routeRendererFactory: {
+					getPageRenderer: vi.fn(),
+					getExplicitViewRenderer: vi.fn(() => ({
+						renderToResponse,
+					})),
+				} satisfies StaticGenerationRendererFactory,
+				staticRoutes: [
+					{
+						path: '/blog/[slug]',
+						loader: async () => ({
+							default: Object.assign(() => null, {
+								config: { __eco: testInjectedMeta },
+								staticPaths: async () => ({ paths: [{ params: { slug: 'hello-world' } }] }),
+								staticProps,
+							}),
+						}),
+					},
+				],
+			});
+
+			expect(staticProps).toHaveBeenCalledWith({
+				pathname: { params: { slug: 'hello-world' } },
+				appConfig: expect.any(Object),
+				runtimeOrigin: 'http://localhost:3000',
+			});
+			expect(renderToResponse).toHaveBeenCalledWith(expect.any(Function), { slug: 'hello-world' }, {});
+			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/blog/hello-world.html', '<html>Post</html>');
+		});
+
+		test('should log an error for dynamic explicit routes without staticPaths', async () => {
+			const ssg = new StaticSiteGenerator({
+				appConfig: createMockConfig({ baseUrl: 'http://localhost:3000' } as any),
+			});
+
+			await ssg.run({
+				router: {
+					listStaticGenerationRoutes: vi.fn(async () => []),
+				} satisfies StaticGenerationRunnerInput['router'],
+				baseUrl: 'http://localhost:3000',
+				routeRendererFactory: {
+					getPageRenderer: vi.fn(),
+					getExplicitViewRenderer: vi.fn(() => ({
+						renderToResponse: vi.fn(),
+					})),
+				} satisfies StaticGenerationRendererFactory,
+				staticRoutes: [
+					{
+						path: '/blog/[slug]',
+						loader: async () => ({
+							default: Object.assign(() => null, {
+								config: { __eco: testInjectedMeta },
+							}),
+						}),
+					},
+				],
+			});
+
+			expect(writeMock).not.toHaveBeenCalledWith('/test/project/dist/blog/hello-world.html', expect.anything());
+		});
+	});
+});