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

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

@@ -0,0 +1,223 @@
+import { describe, test, expect } from 'vitest';
+import { z } from 'zod';
+import * as v from 'valibot';
+import { type } from 'arktype';
+import { SchemaValidationService } from './schema-validation-service.ts';
+
+describe('SchemaValidationService', () => {
+	const service = new SchemaValidationService();
+
+	describe('Zod validation', () => {
+		test('validates body with Zod schema', async () => {
+			const schema = z.object({
+				title: z.string().min(1),
+				count: z.number(),
+			});
+
+			const result = await service.validateRequest(
+				{ body: { title: 'Hello', count: 42 } },
+				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
+			);
+
+			expect(result.success).toBe(true);
+			expect(result.data?.body).toEqual({ title: 'Hello', count: 42 });
+		});
+
+		test('rejects invalid body with Zod schema', async () => {
+			const schema = z.object({
+				title: z.string().min(1),
+				count: z.number(),
+			});
+
+			const result = await service.validateRequest(
+				{ body: { title: '', count: 'not-a-number' } },
+				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.errors).toBeDefined();
+			expect(result.errors!.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe('Valibot validation', () => {
+		test('validates query with Valibot schema', async () => {
+			const schema = v.object({
+				page: v.string(),
+				limit: v.string(),
+			});
+
+			const result = await service.validateRequest(
+				{ query: { page: '1', limit: '10' } },
+				{ query: schema as unknown as Parameters<typeof service.validateRequest>[1]['query'] },
+			);
+
+			expect(result.success).toBe(true);
+			expect(result.data?.query).toEqual({ page: '1', limit: '10' });
+		});
+
+		test('rejects invalid query with Valibot schema', async () => {
+			const schema = v.object({
+				page: v.pipe(v.string(), v.minLength(1)),
+			});
+
+			const result = await service.validateRequest(
+				{ query: { page: '' } },
+				{ query: schema as unknown as Parameters<typeof service.validateRequest>[1]['query'] },
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.errors).toBeDefined();
+		});
+	});
+
+	describe('ArkType validation', () => {
+		test('validates headers with ArkType schema', async () => {
+			const schema = type({
+				'content-type': 'string',
+				authorization: 'string',
+			});
+
+			const result = await service.validateRequest(
+				{
+					headers: {
+						'content-type': 'application/json',
+						authorization: 'Bearer token',
+					},
+				},
+				{ headers: schema as unknown as Parameters<typeof service.validateRequest>[1]['headers'] },
+			);
+
+			expect(result.success).toBe(true);
+			expect(result.data?.headers).toEqual({
+				'content-type': 'application/json',
+				authorization: 'Bearer token',
+			});
+		});
+
+		test('rejects invalid headers with ArkType schema', async () => {
+			const schema = type({
+				'content-type': 'string',
+				'x-custom': 'string>5',
+			});
+
+			const result = await service.validateRequest(
+				{
+					headers: {
+						'content-type': 'application/json',
+						'x-custom': 'ab',
+					},
+				},
+				{ headers: schema as unknown as Parameters<typeof service.validateRequest>[1]['headers'] },
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.errors).toBeDefined();
+		});
+	});
+
+	describe('Combined validation', () => {
+		test('validates multiple sources at once', async () => {
+			const bodySchema = z.object({
+				title: z.string(),
+			});
+			const querySchema = v.object({
+				format: v.string(),
+			});
+
+			const result = await service.validateRequest(
+				{
+					body: { title: 'Post Title' },
+					query: { format: 'json' },
+				},
+				{
+					body: bodySchema as unknown as Parameters<typeof service.validateRequest>[1]['body'],
+					query: querySchema as unknown as Parameters<typeof service.validateRequest>[1]['query'],
+				},
+			);
+
+			expect(result.success).toBe(true);
+			expect(result.data?.body).toEqual({ title: 'Post Title' });
+			expect(result.data?.query).toEqual({ format: 'json' });
+		});
+
+		test('validates route params with schema', async () => {
+			const paramsSchema = z.object({
+				id: z.coerce.number().int(),
+			});
+
+			const result = await service.validateRequest(
+				{
+					params: { id: '42' },
+				},
+				{
+					params: paramsSchema as unknown as Parameters<typeof service.validateRequest>[1]['params'],
+				},
+			);
+
+			expect(result.success).toBe(true);
+			expect(result.data?.params).toEqual({ id: 42 });
+		});
+
+		test('aggregates errors from multiple sources', async () => {
+			const bodySchema = z.object({
+				title: z.string().min(5),
+			});
+			const querySchema = v.object({
+				page: v.pipe(v.string(), v.regex(/^\d+$/)),
+			});
+
+			const result = await service.validateRequest(
+				{
+					body: { title: 'ab' },
+					query: { page: 'invalid' },
+				},
+				{
+					body: bodySchema as unknown as Parameters<typeof service.validateRequest>[1]['body'],
+					query: querySchema as unknown as Parameters<typeof service.validateRequest>[1]['query'],
+				},
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.errors).toBeDefined();
+			expect(result.errors!.length).toBeGreaterThan(1);
+		});
+	});
+
+	describe('Edge cases', () => {
+		test('handles missing optional schemas', async () => {
+			const result = await service.validateRequest({ body: { data: 'test' } }, {});
+
+			expect(result.success).toBe(true);
+			expect(result.data).toEqual({});
+		});
+
+		test('handles undefined source data', async () => {
+			const schema = z.object({ name: z.string() });
+
+			const result = await service.validateRequest(
+				{ body: undefined },
+				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
+			);
+
+			expect(result.success).toBe(true);
+		});
+
+		test('catches validation exceptions', async () => {
+			const brokenSchema = {
+				'~standard': {
+					version: 1,
+					vendor: 'test',
+					validate: () => {
+						throw new Error('Validation crashed');
+					},
+				},
+			} as const;
+
+			const result = await service.validateRequest({ body: { test: true } }, { body: brokenSchema });
+
+			expect(result.success).toBe(false);
+			expect(result.errors?.[0]?.message).toBe('Validation crashed');
+		});
+	});
+});

package/src/services/{schema-validation-service.ts → validation/schema-validation-service.ts}

@@ -1,4 +1,4 @@
-import type { StandardSchema, StandardSchemaIssue } from './validation/standard-schema.types.ts';
+import type { StandardSchema, StandardSchemaIssue } from './standard-schema.types.js';
 
 export interface ValidationResult<T = unknown> {
 	success: boolean;

package/src/static-site-generator/README.md

@@ -0,0 +1,26 @@
+# Static Site Generation
+
+This directory contains the static-build execution path used when Ecopages renders pages ahead of time.
+
+## Purpose
+
+The static-site generator reuses the same app-owned config, route matching, and rendering services that development and preview flows use, but drives them in a build-oriented loop.
+
+It is responsible for:
+
+- enumerating renderable routes
+- rendering static outputs through the normal rendering pipeline
+- respecting route-level constraints such as cache policy and unsupported dynamic server-only paths
+
+## Design Rule
+
+Static generation should follow the same ownership model as runtime rendering.
+
+That means it should reuse:
+
+- built app config
+- route matching
+- render orchestration
+- asset processing
+
+It should not invent a parallel rendering stack just for build mode.

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

@@ -0,0 +1,307 @@
+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 '../internal-types';
+import type { FSRouter } from '../router/server/fs-router';
+import type { RouteRendererFactory } from '../route-renderer/route-renderer';
+import { appLogger } from '../global/app-logger.ts';
+import { PageModuleImportService } from '../services/module-loading/page-module-import.service';
+import { DEFAULT_ECOPAGES_WORK_DIR } from '../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;
+
+describe('StaticSiteGenerator', () => {
+	let ensureDirMock: any;
+	let writeMock: any;
+
+	beforeEach(() => {
+		ensureDirMock = vi.fn(() => {});
+		writeMock = vi.fn(() => {});
+		fileSystem.ensureDir = ensureDirMock;
+		fileSystem.write = writeMock;
+		vi.spyOn(PageModuleImportService.prototype, 'importModule').mockResolvedValue({
+			default: Object.assign(() => null, { cache: 'static' }),
+		});
+		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 }>) =>
+			({
+				routes: Object.fromEntries(
+					Object.entries(routes).map(([key, value]) => [key, { ...value, kind: 'exact' }]),
+				),
+				origin: 'http://localhost:3000',
+			}) as unknown as FSRouter;
+
+		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 = {
+				createRenderer: vi.fn(() => ({
+					createRoute: vi.fn(async () => ({ body: '<html>Static</html>' })),
+				})),
+			} as unknown as RouteRendererFactory;
+
+			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 = {
+				createRenderer: vi.fn(() => ({
+					createRoute: vi.fn(async () => ({ body: '<html>Blog Post</html>' })),
+				})),
+			} as unknown as RouteRendererFactory;
+
+			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 = {
+				createRenderer: vi.fn(() => ({
+					createRoute: vi.fn(async () => ({ body: '<html>Home</html>' })),
+				})),
+			} as unknown as RouteRendererFactory;
+
+			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 = {
+				createRenderer: vi.fn(() => ({
+					createRoute: vi.fn(async () => ({ body: bufferContent })),
+				})),
+			} as unknown as RouteRendererFactory;
+
+			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 () => {
+			vi.spyOn(PageModuleImportService.prototype, 'importModule').mockResolvedValue({
+				default: Object.assign(() => null, { cache: 'dynamic' }),
+			});
+
+			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
+			const Router = createMockRouter({
+				'/dashboard': { filePath: '/src/pages/dashboard.tsx', pathname: '/dashboard' },
+			});
+
+			const RendererFactory = {
+				createRenderer: vi.fn(() => ({
+					createRoute: vi.fn(async () => ({ body: '<html>Dashboard</html>' })),
+				})),
+			} as unknown as RouteRendererFactory;
+
+			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
+
+			expect(RendererFactory.createRenderer).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 = {
+				routes: {},
+				origin: 'http://localhost:3000',
+			} as unknown as FSRouter;
+
+			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: {
+					routes: {},
+					origin: 'http://localhost:3000',
+				} as unknown as FSRouter,
+				baseUrl: 'http://localhost:3000',
+				routeRendererFactory: {
+					getRendererByIntegration: vi.fn(),
+				} as unknown as RouteRendererFactory,
+				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',
+			);
+		});
+	});
+});