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

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

@@ -1,204 +0,0 @@
-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/static-site-generator/static-site-generator.test.ts

@@ -1,408 +0,0 @@
-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());
-		});
-	});
-});