@ecopages/core 0.2.0-alpha.23 → 0.2.0-alpha.25

package/src/router/server/fs-router-scanner.ts

@@ -0,0 +1,224 @@
+import path from 'node:path';
+import { appLogger } from '../../global/app-logger.ts';
+import type { EcoPagesAppConfig, RouteKind, Routes } from '../../types/internal-types.ts';
+import type { EcoPageFile, GetStaticPaths } from '../../types/public-types.ts';
+import { fileSystem } from '@ecopages/file-system';
+import { invariant } from '../../utils/invariant.ts';
+import { existsSync } from 'node:fs';
+import { getAppServerModuleTranspiler } from '../../services/module-loading/app-server-module-transpiler.service.ts';
+import type { ServerModuleTranspiler } from '../../services/module-loading/server-module-transpiler.service.ts';
+import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
+
+type CreateRouteArgs = {
+	routePath: string;
+	filePath: string;
+	route: string;
+};
+
+type FSRouterScannerOptions = {
+	buildMode: boolean;
+};
+
+/**
+ * @class FSRouterScanner
+ * @description
+ * This class is responsible for scanning the file system for routes.
+ * It uses the glob package to scan the file system for files with the specified file extensions.
+ * It then creates a map of the routes with the pathname as the key.
+ * The pathname is the route without the file extension.
+ * For example, if the file is "index.tsx", the pathname will be "/index".
+ * If the file is "blog/[slug].tsx", the pathname will be "/blog/[slug]".
+ * If the file is "blog/[...slug].tsx", the pathname will be "/blog/[...slug]".
+ */
+export class FSRouterScanner {
+	private dir: string;
+	private origin = '';
+	private templatesExt: string[];
+	private options: FSRouterScannerOptions;
+	readonly appConfig: EcoPagesAppConfig;
+	routes: Routes = {};
+	private serverModuleTranspiler: ServerModuleTranspiler;
+
+	constructor({
+		dir,
+		origin,
+		templatesExt,
+		options,
+		appConfig,
+	}: {
+		dir: string;
+		origin: string;
+		templatesExt: string[];
+		options: FSRouterScannerOptions;
+		appConfig: EcoPagesAppConfig;
+	}) {
+		this.dir = dir;
+		this.origin = origin;
+		this.templatesExt = templatesExt;
+		this.options = options;
+		this.appConfig = appConfig;
+		this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
+	}
+
+	private getRoutePath(path: string): string {
+		const cleanedRoute = this.templatesExt
+			.reduce((route, ext) => route.replace(ext, ''), path)
+			.replace(/\/?index$/, '');
+		return `/${cleanedRoute}`;
+	}
+
+	private getDynamicParamsNames(route: string): string[] {
+		const matches = route.match(/\[.*?\]/g);
+		return matches ? matches.map((match) => match.slice(1, -1)) : [];
+	}
+
+	private async getStaticPathsFromDynamicRoute({
+		route,
+		filePath,
+		getStaticPaths,
+	}: {
+		route: string;
+		filePath: string;
+		getStaticPaths: GetStaticPaths;
+	}): Promise<string[]> {
+		const staticPaths = await getStaticPaths({
+			appConfig: this.appConfig,
+			runtimeOrigin: this.origin,
+		});
+		return staticPaths.paths.map((path) => {
+			const dynamicParamsNames = this.getDynamicParamsNames(filePath);
+			let routeWithParams = route;
+
+			for (const param of dynamicParamsNames) {
+				routeWithParams = routeWithParams.replace(`[${param}]`, (path.params as Record<string, string>)[param]);
+			}
+
+			return routeWithParams;
+		});
+	}
+
+	private async createStaticRoutes({
+		filePath,
+		route,
+		routePath,
+		getStaticPaths,
+	}: CreateRouteArgs & { getStaticPaths: GetStaticPaths }): Promise<void> {
+		try {
+			const routesWithParams = await this.getStaticPathsFromDynamicRoute({
+				route,
+				filePath,
+				getStaticPaths,
+			});
+
+			for (const routeWithParams of routesWithParams) {
+				this.createRoute('dynamic', { filePath, route: routeWithParams, routePath });
+			}
+		} catch (error) {
+			appLogger.error(`[ecopages] Error creating static routes for ${filePath}: ${error}`);
+		}
+	}
+
+	private async handleDynamicRouteCreation({ filePath, route, routePath }: CreateRouteArgs): Promise<void> {
+		const module = (await this.importPageModule(filePath)) as EcoPageFile;
+		const Page = module.default;
+
+		/**
+		 * Check for attached static functions (consolidated API) or named exports (legacy)
+		 */
+		const getStaticPaths = Page?.staticPaths ?? module.getStaticPaths;
+		const getStaticProps = Page?.staticProps ?? module.getStaticProps;
+
+		if (this.options.buildMode) {
+			invariant(getStaticProps !== undefined, `[ecopages] Missing getStaticProps in ${filePath}`);
+			invariant(getStaticPaths !== undefined, `[ecopages] Missing getStaticPaths in ${filePath}`);
+		}
+
+		if (getStaticPaths) {
+			return this.createStaticRoutes({
+				filePath,
+				route,
+				routePath,
+				getStaticPaths,
+			});
+		}
+
+		return this.createRoute('dynamic', { filePath, route, routePath });
+	}
+
+	private async importPageModule(filePath: string): Promise<unknown> {
+		return this.serverModuleTranspiler.importModule({
+			filePath,
+			outdir: path.join(resolveInternalExecutionDir(this.appConfig), '.server-route-modules'),
+			externalPackages: false,
+			transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
+			noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`,
+		});
+	}
+
+	private createRoute(kind: RouteKind, { filePath, route, routePath }: CreateRouteArgs): void {
+		this.routes[route] = {
+			kind,
+			pathname: routePath,
+			filePath,
+		};
+	}
+
+	private getRouteData(file: string): CreateRouteArgs & {
+		kind: RouteKind;
+	} {
+		const routePath = this.getRoutePath(file);
+		const route = `${this.origin}${routePath}`;
+		const filePath = path.join(this.dir, file);
+		const isCatchAll = filePath.includes('[...');
+		const isDynamic = !isCatchAll && filePath.includes('[') && filePath.includes(']');
+		let kind: RouteKind = 'exact';
+		if (isCatchAll) {
+			kind = 'catch-all';
+		} else if (isDynamic) {
+			kind = 'dynamic';
+		}
+
+		return { route, routePath, filePath, kind };
+	}
+
+	async scan(): Promise<Routes> {
+		this.routes = {};
+
+		if (!existsSync(this.dir)) {
+			return this.routes;
+		}
+
+		const scannedFiles = await fileSystem.glob(
+			this.templatesExt.map((ext) => `**/*${ext}`),
+			{ cwd: this.dir },
+		);
+
+		for await (const file of scannedFiles) {
+			if (file.includes('.ecopages-node.')) {
+				continue;
+			}
+
+			const { kind, ...routeData } = this.getRouteData(file);
+
+			switch (kind) {
+				case 'dynamic':
+					await this.handleDynamicRouteCreation(routeData);
+					break;
+				case 'catch-all':
+					if (this.options.buildMode) {
+						appLogger.warn(
+							'Catch-all routes are not supported in static generation, they will not be included in the bundle\n',
+							`➤ ${routeData.filePath}`,
+						);
+					}
+					this.createRoute(kind, routeData);
+					break;
+				default:
+					this.createRoute(kind, routeData);
+					break;
+			}
+		}
+
+		return this.routes;
+	}
+}

package/src/router/server/fs-router.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, test, vi } from 'vitest';
+import { FIXTURE_APP_PROJECT_DIR } from '../../../__fixtures__/constants.js';
+import { ConfigBuilder } from '../../config/config-builder.js';
+import type { Route, Routes } from '../../types/internal-types.js';
+import { FSRouter } from './fs-router.ts';
+import { FSRouterScanner } from './fs-router-scanner.ts';
+
+const {
+	templatesExt,
+	absolutePaths: { pagesDir, distDir },
+} = await new ConfigBuilder().setRootDir(FIXTURE_APP_PROJECT_DIR).build();
+
+const scanner = new FSRouterScanner({
+	dir: pagesDir,
+	appConfig: {
+		absolutePaths: {
+			distDir,
+		},
+	} as any,
+	origin: 'http://localhost:3000',
+	templatesExt,
+	options: {
+		buildMode: false,
+	},
+});
+
+const router = new FSRouter({
+	origin: 'http://localhost:3000',
+	assetPrefix: distDir,
+	scanner,
+});
+
+await router.init();
+
+describe('FSRouter', async () => {
+	describe('init', async () => {
+		test('should scan and return routes', async () => {
+			expect(Object.keys(router.routes).sort()).toEqual([
+				'http://localhost:3000/',
+				'http://localhost:3000/404',
+				'http://localhost:3000/catch-all/[...path]',
+				'http://localhost:3000/dynamic/another-blog-post',
+				'http://localhost:3000/dynamic/blog-post',
+				'http://localhost:3000/postcss-hmr',
+			]);
+		});
+	});
+
+	describe('getDynamicParams', async () => {
+		test.each([
+			['/products/[id]', '/products/123', { id: '123' }],
+			['/products/[id]', '/products/123/456', { id: '123' }],
+			['/products/[id]', '/products/123/456/789', { id: '123' }],
+		])(
+			'dynamic route %p with URL %p should have dynamic params %p',
+			async (dynamicPathname, pathname, expected) => {
+				const route: Route = {
+					filePath: '',
+					kind: 'dynamic',
+					pathname: dynamicPathname,
+				};
+				const params = router.getDynamicParams(route, pathname);
+
+				expect(params).toEqual(expected);
+			},
+		);
+
+		test.each([
+			['/products/[...id]', '/products/123/456/789', { id: ['123', '456', '789'] }],
+			['/products/[...id]', '/products/123', { id: ['123'] }],
+			['/products/[...id]', '/products', { id: [] }],
+		])(
+			'catch-all route %p with URL %p should have dynamic params %p',
+			async (catchAllRoute, pathname, expected) => {
+				const route: Route = {
+					filePath: '',
+					kind: 'dynamic',
+					pathname: catchAllRoute,
+				};
+				const params = router.getDynamicParams(route, pathname);
+
+				expect(params).toEqual(expected);
+			},
+		);
+	});
+
+	describe('getSearchParams', () => {
+		test('should extract query parameters from URL', () => {
+			const url = new URL('http://localhost:3000/page?foo=bar&baz=qux');
+			const params = router.getSearchParams(url);
+
+			expect(params).toEqual({ foo: 'bar', baz: 'qux' });
+		});
+
+		test('should return empty object for URL without query params', () => {
+			const url = new URL('http://localhost:3000/page');
+			const params = router.getSearchParams(url);
+
+			expect(params).toEqual({});
+		});
+	});
+
+	describe('match', () => {
+		const createRouterWithRoutes = (routes: Routes) => {
+			const Scanner = { scan: async () => routes } as unknown as FSRouterScanner;
+			const testRouter = new FSRouter({
+				origin: 'http://localhost:3000',
+				assetPrefix: '/dist',
+				scanner: Scanner,
+			});
+			testRouter.routes = routes;
+			return testRouter;
+		};
+
+		test('should match exact route', () => {
+			const testRouter = createRouterWithRoutes({
+				'/about': { filePath: '/pages/about.ts', kind: 'exact', pathname: '/about' },
+			});
+
+			const result = testRouter.match('http://localhost:3000/about');
+
+			expect(result).not.toBeNull();
+			expect(result?.kind).toBe('exact');
+			expect(result?.pathname).toBe('/about');
+		});
+
+		test('should match exact route with trailing slash', () => {
+			const testRouter = createRouterWithRoutes({
+				'/about': { filePath: '/pages/about.ts', kind: 'exact', pathname: '/about' },
+			});
+
+			const result = testRouter.match('http://localhost:3000/about/');
+
+			expect(result).not.toBeNull();
+			expect(result?.kind).toBe('exact');
+		});
+
+		test('should match dynamic route', () => {
+			const testRouter = createRouterWithRoutes({
+				'/dynamic/[id]': { filePath: '/pages/dynamic/[id].ts', kind: 'dynamic', pathname: '/dynamic/[id]' },
+			});
+
+			const result = testRouter.match('http://localhost:3000/dynamic/123');
+
+			expect(result).not.toBeNull();
+			expect(result?.kind).toBe('dynamic');
+			expect(result?.params).toEqual({ id: '123' });
+		});
+
+		test('should match catch-all route', () => {
+			const testRouter = createRouterWithRoutes({
+				'/catch-all/[...slug]': {
+					filePath: '/pages/catch-all/[...slug].ts',
+					kind: 'catch-all',
+					pathname: '/catch-all/[...slug]',
+				},
+			});
+
+			const result = testRouter.match('http://localhost:3000/catch-all/a/b/c');
+
+			expect(result).not.toBeNull();
+			expect(result?.kind).toBe('catch-all');
+			expect(result?.params).toEqual({ slug: ['a', 'b', 'c'] });
+		});
+
+		test('should include query params in match result', () => {
+			const testRouter = createRouterWithRoutes({
+				'/page': { filePath: '/pages/page.ts', kind: 'exact', pathname: '/page' },
+			});
+
+			const result = testRouter.match('http://localhost:3000/page?sort=asc&page=2');
+
+			expect(result?.query).toEqual({ sort: 'asc', page: '2' });
+		});
+
+		test('should return null for non-matching route', () => {
+			const testRouter = createRouterWithRoutes({
+				'/about': { filePath: '/pages/about.ts', kind: 'exact', pathname: '/about' },
+			});
+
+			const result = testRouter.match('http://localhost:3000/contact');
+
+			expect(result).toBeNull();
+		});
+
+		test('should prefer exact match over dynamic', () => {
+			const testRouter = createRouterWithRoutes({
+				'/blog/latest': { filePath: '/pages/blog/latest.ts', kind: 'exact', pathname: '/blog/latest' },
+				'/blog/[slug]': { filePath: '/pages/blog/[slug].ts', kind: 'dynamic', pathname: '/blog/[slug]' },
+			});
+
+			const result = testRouter.match('http://localhost:3000/blog/latest');
+
+			expect(result?.kind).toBe('exact');
+		});
+	});
+
+	describe('setOnReload and reload', () => {
+		test('should set and call onReload callback', async () => {
+			const Scanner = { scan: async () => ({}) } as unknown as FSRouterScanner;
+			const testRouter = new FSRouter({
+				origin: 'http://localhost:3000',
+				assetPrefix: '/dist',
+				scanner: Scanner,
+			});
+
+			const callback = vi.fn(() => {});
+			testRouter.setOnReload(callback);
+			testRouter.reload();
+
+			expect(callback).toHaveBeenCalledTimes(1);
+		});
+	});
+});

package/src/router/server/fs-router.ts

@@ -0,0 +1,122 @@
+import { appLogger } from '../../global/app-logger.ts';
+import type { MatchResult, Route, Routes } from '../../types/internal-types.ts';
+import type { FSRouterScanner } from './fs-router-scanner.ts';
+
+/**
+ * A class that manages the routes of the file system.
+ * It scans the file system for files with the specified extensions and creates a map of routes.
+ * It also provides a method to match a request to a route.
+ * It can be used to reload the routes when the file system changes.
+ */
+export class FSRouter {
+	origin: string;
+	assetPrefix: string;
+	routes: Routes = {};
+	scanner: FSRouterScanner;
+	onReload?: () => void;
+
+	constructor({ origin, assetPrefix, scanner }: { origin: string; assetPrefix: string; scanner: FSRouterScanner }) {
+		this.origin = origin;
+		this.assetPrefix = assetPrefix;
+		this.scanner = scanner;
+	}
+
+	async init() {
+		this.routes = await this.scanner.scan();
+		appLogger.debug('FSRouter initialized', this.routes);
+	}
+
+	getDynamicParams(route: Route, pathname: string): Record<string, string | string[]> {
+		const params: Record<string, string | string[]> = {};
+		const routeParts = route.pathname.split('/');
+		const pathnameParts = pathname.split('/');
+
+		for (let i = 0; i < routeParts.length; i++) {
+			const part = routeParts[i];
+			if (part.startsWith('[') && part.endsWith(']')) {
+				if (part.startsWith('[...')) {
+					const param = part.slice(4, -1);
+					params[param] = pathnameParts.slice(i);
+					break;
+				}
+				const param = part.slice(1, -1);
+				params[param] = pathnameParts[i];
+			}
+		}
+		return params;
+	}
+
+	getSearchParams(url: URL): Record<string, string> {
+		const query: Record<string, string> = {};
+		for (const [key, value] of url.searchParams) {
+			query[key] = value;
+		}
+		return query;
+	}
+
+	match(requestUrl: string): MatchResult | null {
+		const url = new URL(requestUrl);
+		const pathname = url.pathname.replace(this.origin, '');
+
+		const routeValues = Object.values(this.routes);
+
+		for (const route of routeValues) {
+			if (route.kind === 'exact' && (pathname === route.pathname || pathname === `${route.pathname}/`)) {
+				return {
+					filePath: route.filePath,
+					kind: 'exact',
+					pathname: route.pathname,
+					query: this.getSearchParams(url),
+				};
+			}
+		}
+
+		for (const route of routeValues) {
+			const cleanPathname = route.pathname.replace(/\[.*?\]/g, '');
+			const isValidDynamicRoute = pathname.includes(cleanPathname);
+
+			if (route.kind === 'dynamic' && isValidDynamicRoute) {
+				const routeParts = route.pathname.split('/');
+				const pathnameParts = pathname.split('/');
+
+				if (routeParts.length === pathnameParts.length) {
+					return {
+						filePath: route.filePath,
+						kind: 'dynamic',
+						pathname: pathname,
+						query: this.getSearchParams(url),
+						params: this.getDynamicParams(route, pathname),
+					};
+				}
+			}
+		}
+
+		for (const route of routeValues) {
+			const cleanPathname = route.pathname.replace(/\[.*?\]/g, '');
+			const isValidCatchAllRoute = pathname.includes(cleanPathname);
+
+			if (route.kind === 'catch-all' && isValidCatchAllRoute) {
+				return {
+					filePath: route.filePath,
+					kind: 'catch-all',
+					pathname: pathname,
+					query: this.getSearchParams(url),
+					params: this.getDynamicParams(route, pathname),
+				};
+			}
+		}
+
+		return null;
+	}
+
+	setOnReload(cb: () => void) {
+		this.onReload = cb;
+	}
+
+	reload() {
+		this.init();
+		if (this.onReload) {
+			this.onReload();
+		}
+	}
+}

package/src/services/assets/asset-processing-service/asset-dependency-keys.ts

@@ -0,0 +1,66 @@
+import { rapidhash } from '../../../utils/hash.ts';
+import type { AssetDefinition } from './assets.types.ts';
+
+function generateHash(content: string): string {
+	return rapidhash(content).toString();
+}
+
+function getScriptDependencyBuildSignature(dep: AssetDefinition): string | undefined {
+	if (dep.kind !== 'script') {
+		return undefined;
+	}
+
+	const pluginNames = dep.bundleOptions?.plugins?.map((plugin) => plugin.name) ?? [];
+	const signature = {
+		bundle: dep.bundle,
+		inline: dep.inline,
+		excludeFromHtml: dep.excludeFromHtml,
+		groupedBundle: dep.groupedBundle,
+		naming: dep.bundleOptions?.naming,
+		external: dep.bundleOptions?.external,
+		minify: dep.bundleOptions?.minify,
+		plugins: pluginNames,
+	};
+
+	return generateHash(JSON.stringify(signature));
+}
+
+export function getAssetDependencyKey(dep: AssetDefinition): string {
+	const parts: string[] = [dep.kind, dep.source];
+
+	if ('filepath' in dep) {
+		parts.push(dep.filepath);
+	} else if ('content' in dep) {
+		parts.push(`content:${generateHash(dep.content)}`);
+	} else if ('importPath' in dep) {
+		parts.push(dep.importPath);
+	}
+
+	if ('position' in dep && dep.position) {
+		parts.push(dep.position);
+	}
+
+	if ('packageRole' in dep && dep.packageRole) {
+		parts.push(`package:${dep.packageRole}`);
+	}
+
+	const scriptBuildSignature = getScriptDependencyBuildSignature(dep);
+	if (scriptBuildSignature) {
+		parts.push(`build:${scriptBuildSignature}`);
+	}
+
+	return parts.join(':');
+}
+
+export function deduplicateAssetDependencies(deps: AssetDefinition[]): AssetDefinition[] {
+	const seen = new Map<string, AssetDefinition>();
+
+	for (const dep of deps) {
+		const key = getAssetDependencyKey(dep);
+		if (!seen.has(key)) {
+			seen.set(key, dep);
+		}
+	}
+
+	return Array.from(seen.values());
+}