@ecopages/core 0.2.0-alpha.24 → 0.2.0-alpha.26

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

@@ -1,224 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

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