@ecopages/core 0.2.0-alpha.1

package/src/router/fs-router-scanner.js

@@ -0,0 +1,155 @@
+import path from "node:path";
+import { appLogger } from "../global/app-logger.js";
+import { fileSystem } from "@ecopages/file-system";
+import { invariant } from "../utils/invariant.js";
+import { existsSync } from "node:fs";
+import { PageModuleImportService } from "../services/page-module-import.service.js";
+class FSRouterScanner {
+  dir;
+  origin = "";
+  templatesExt;
+  options;
+  appConfig;
+  routes = {};
+  pageModuleImportService = new PageModuleImportService();
+  constructor({
+    dir,
+    origin,
+    templatesExt,
+    options,
+    appConfig
+  }) {
+    this.dir = dir;
+    this.origin = origin;
+    this.templatesExt = templatesExt;
+    this.options = options;
+    this.appConfig = appConfig;
+  }
+  getRoutePath(path2) {
+    const cleanedRoute = this.templatesExt.reduce((route, ext) => route.replace(ext, ""), path2).replace(/\/?index$/, "");
+    return `/${cleanedRoute}`;
+  }
+  getDynamicParamsNames(route) {
+    const matches = route.match(/\[.*?\]/g);
+    return matches ? matches.map((match) => match.slice(1, -1)) : [];
+  }
+  async getStaticPathsFromDynamicRoute({
+    route,
+    filePath,
+    getStaticPaths
+  }) {
+    const staticPaths = await getStaticPaths({
+      appConfig: this.appConfig,
+      runtimeOrigin: this.origin
+    });
+    return staticPaths.paths.map((path2) => {
+      const dynamicParamsNames = this.getDynamicParamsNames(filePath);
+      let routeWithParams = route;
+      for (const param of dynamicParamsNames) {
+        routeWithParams = routeWithParams.replace(`[${param}]`, path2.params[param]);
+      }
+      return routeWithParams;
+    });
+  }
+  async createStaticRoutes({
+    filePath,
+    route,
+    routePath,
+    getStaticPaths
+  }) {
+    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}`);
+    }
+  }
+  async handleDynamicRouteCreation({ filePath, route, routePath }) {
+    const module = await this.importPageModule(filePath);
+    const Page = module.default;
+    const getStaticPaths = Page?.staticPaths ?? module.getStaticPaths;
+    const getStaticProps = Page?.staticProps ?? module.getStaticProps;
+    if (this.options.buildMode) {
+      invariant(getStaticProps !== void 0, `[ecopages] Missing getStaticProps in ${filePath}`);
+      invariant(getStaticPaths !== void 0, `[ecopages] Missing getStaticPaths in ${filePath}`);
+    }
+    if (getStaticPaths) {
+      return this.createStaticRoutes({
+        filePath,
+        route,
+        routePath,
+        getStaticPaths
+      });
+    }
+    return this.createRoute("dynamic", { filePath, route, routePath });
+  }
+  async importPageModule(filePath) {
+    return this.pageModuleImportService.importModule({
+      filePath,
+      rootDir: this.appConfig.rootDir,
+      outdir: path.join(this.appConfig.absolutePaths.distDir, ".server-route-modules"),
+      externalPackages: false,
+      transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
+      noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`
+    });
+  }
+  createRoute(kind, { filePath, route, routePath }) {
+    this.routes[route] = {
+      kind,
+      pathname: routePath,
+      filePath
+    };
+  }
+  getRouteData(file) {
+    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("]");
+    const kind = isCatchAll ? "catch-all" : isDynamic ? "dynamic" : "exact";
+    return { route, routePath, filePath, kind };
+  }
+  async scan() {
+    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",
+              `\u27A4 ${routeData.filePath}`
+            );
+          }
+          this.createRoute(kind, routeData);
+          break;
+        default:
+          this.createRoute(kind, routeData);
+          break;
+      }
+    }
+    return this.routes;
+  }
+}
+export {
+  FSRouterScanner
+};

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

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { appLogger } from '../global/app-logger.ts';
+import type { EcoPagesAppConfig, RouteKind, Routes } from '../internal-types.ts';
+import type { EcoPageFile, GetStaticPaths } from '../public-types.ts';
+import { fileSystem } from '@ecopages/file-system';
+import { invariant } from '../utils/invariant.ts';
+import { existsSync } from 'node:fs';
+import { PageModuleImportService } from '../services/page-module-import.service.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;
+	private appConfig: EcoPagesAppConfig;
+	routes: Routes = {};
+	private pageModuleImportService = new PageModuleImportService();
+
+	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;
+	}
+
+	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.pageModuleImportService.importModule({
+			filePath,
+			rootDir: this.appConfig.rootDir,
+			outdir: path.join(this.appConfig.absolutePaths.distDir, '.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(']');
+		const kind: RouteKind = isCatchAll ? 'catch-all' : isDynamic ? 'dynamic' : 'exact';
+
+		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/fs-router.d.ts

@@ -0,0 +1,26 @@
+import type { MatchResult, Route, Routes } from '../internal-types.js';
+import type { FSRouterScanner } from './fs-router-scanner.js';
+/**
+ * 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 declare class FSRouter {
+    origin: string;
+    assetPrefix: string;
+    routes: Routes;
+    scanner: FSRouterScanner;
+    onReload?: () => void;
+    constructor({ origin, assetPrefix, scanner }: {
+        origin: string;
+        assetPrefix: string;
+        scanner: FSRouterScanner;
+    });
+    init(): Promise<void>;
+    getDynamicParams(route: Route, pathname: string): Record<string, string | string[]>;
+    getSearchParams(url: URL): Record<string, string>;
+    match(requestUrl: string): MatchResult | null;
+    setOnReload(cb: () => void): void;
+    reload(): void;
+}

package/src/router/fs-router.js

@@ -0,0 +1,100 @@
+import { appLogger } from "../global/app-logger.js";
+class FSRouter {
+  origin;
+  assetPrefix;
+  routes = {};
+  scanner;
+  onReload;
+  constructor({ origin, assetPrefix, scanner }) {
+    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, pathname) {
+    const params = {};
+    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 param2 = part.slice(4, -1);
+          params[param2] = pathnameParts.slice(i);
+          break;
+        }
+        const param = part.slice(1, -1);
+        params[param] = pathnameParts[i];
+      }
+    }
+    return params;
+  }
+  getSearchParams(url) {
+    const query = {};
+    for (const [key, value] of url.searchParams) {
+      query[key] = value;
+    }
+    return query;
+  }
+  match(requestUrl) {
+    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,
+            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,
+          query: this.getSearchParams(url),
+          params: this.getDynamicParams(route, pathname)
+        };
+      }
+    }
+    return null;
+  }
+  setOnReload(cb) {
+    this.onReload = cb;
+  }
+  reload() {
+    this.init();
+    if (this.onReload) {
+      this.onReload();
+    }
+  }
+}
+export {
+  FSRouter
+};

package/src/router/fs-router.ts

@@ -0,0 +1,122 @@
+import { appLogger } from '../global/app-logger.ts';
+import type { MatchResult, Route, Routes } from '../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/asset-processing-service/asset-processing.service.d.ts

@@ -0,0 +1,41 @@
+import type { EcoPagesAppConfig, IHmrManager } from '../../internal-types';
+import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types';
+import { ProcessorRegistry } from './processor.registry';
+export declare class AssetProcessingService {
+    private readonly config;
+    static readonly RESOLVED_ASSETS_DIR = "assets";
+    private registry;
+    private hmrManager?;
+    private cache;
+    constructor(config: EcoPagesAppConfig);
+    /**
+     * Set the HMR manager for the asset processing service.
+     * @param hmrManager The HMR manager to set.
+     */
+    setHmrManager(hmrManager: IHmrManager): void;
+    getHmrManager(): IHmrManager | undefined;
+    /**
+     * Register a processor for a specific asset kind and source.
+     * @param kind The asset kind.
+     * @param variant The asset source.
+     * @param processor The processor to register.
+     */
+    registerProcessor(kind: AssetKind, variant: AssetSource, processor: any): void;
+    processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
+    private deduplicateDependencies;
+    private getScriptDependencyBuildSignature;
+    private getDependencyKey;
+    private generateHash;
+    private processDependenciesParallel;
+    private groupDependenciesByType;
+    private getSrcUrl;
+    private resolveProcessedAssetSrcUrl;
+    private isFilesystemPath;
+    private optimizeDependencies;
+    private getCachedAsset;
+    private setCachedAsset;
+    clearCache(): void;
+    invalidateCacheForFile(filepath: string): void;
+    static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService;
+    getRegistry(): ProcessorRegistry;
+}