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

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

@@ -0,0 +1,161 @@
+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 { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
+class FSRouterScanner {
+  dir;
+  origin = "";
+  templatesExt;
+  options;
+  appConfig;
+  routes = {};
+  serverModuleTranspiler;
+  constructor({
+    dir,
+    origin,
+    templatesExt,
+    options,
+    appConfig
+  }) {
+    this.dir = dir;
+    this.origin = origin;
+    this.templatesExt = templatesExt;
+    this.options = options;
+    this.appConfig = appConfig;
+    this.serverModuleTranspiler = getAppServerModuleTranspiler(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.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}`
+    });
+  }
+  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("]");
+    let kind = "exact";
+    if (isCatchAll) {
+      kind = "catch-all";
+    } else if (isDynamic) {
+      kind = "dynamic";
+    }
+    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/server/fs-router.d.ts

@@ -0,0 +1,26 @@
+import type { MatchResult, Route, Routes } from '../../types/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/server/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/services/assets/asset-processing-service/asset-dependency-keys.d.ts

@@ -0,0 +1,3 @@
+import type { AssetDefinition } from './assets.types.js';
+export declare function getAssetDependencyKey(dep: AssetDefinition): string;
+export declare function deduplicateAssetDependencies(deps: AssetDefinition[]): AssetDefinition[];

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

@@ -0,0 +1,56 @@
+import { rapidhash } from "../../../utils/hash.js";
+function generateHash(content) {
+  return rapidhash(content).toString();
+}
+function getScriptDependencyBuildSignature(dep) {
+  if (dep.kind !== "script") {
+    return void 0;
+  }
+  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));
+}
+function getAssetDependencyKey(dep) {
+  const parts = [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(":");
+}
+function deduplicateAssetDependencies(deps) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const dep of deps) {
+    const key = getAssetDependencyKey(dep);
+    if (!seen.has(key)) {
+      seen.set(key, dep);
+    }
+  }
+  return Array.from(seen.values());
+}
+export {
+  deduplicateAssetDependencies,
+  getAssetDependencyKey
+};

package/src/services/assets/asset-processing-service/asset-processing.service.d.ts

@@ -0,0 +1,103 @@
+import type { EcoPagesAppConfig, IHmrManager } from '../../../types/internal-types.js';
+import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types.js';
+import { ProcessorRegistry } from './processor.registry.js';
+/**
+ * Processes declared component and page asset dependencies for one app instance.
+ *
+ * @remarks
+ * This service is the shared bridge between dependency declarations and emitted
+ * runtime-ready assets. It owns deduplication, processor dispatch, cache reuse,
+ * output URL normalization, and production gzip preparation so route rendering
+ * and HMR flows do not need to understand processor-specific behavior.
+ */
+export declare class AssetProcessingService {
+    static readonly RESOLVED_ASSETS_DIR = "assets";
+    private registry;
+    private hmrManager?;
+    private cache;
+    private readonly config;
+    /**
+     * Creates the asset-processing service bound to one finalized app config.
+     */
+    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;
+    /**
+     * Processes one dependency list into normalized emitted assets.
+     *
+     * @remarks
+     * Dependencies are deduplicated before processor execution so repeated
+     * declarations across the render tree reuse the same emitted outputs and cache
+     * entries.
+     */
+    processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
+    /**
+     * Processes deduplicated dependencies grouped by processor type.
+     *
+     * @remarks
+     * Grouping keeps cache and processor behavior isolated by asset kind/source
+     * pair, while still allowing the overall dependency set to resolve in
+     * parallel.
+     */
+    private processDependenciesParallel;
+    /**
+     * Groups dependencies by processor bucket.
+     */
+    private groupDependenciesByType;
+    /**
+     * Converts a dist-local file path into its public URL.
+     */
+    private getSrcUrl;
+    /**
+     * Normalizes the public source URL for one processed asset.
+     */
+    private resolveProcessedAssetSrcUrl;
+    /**
+     * Returns whether a value should be interpreted as a filesystem path instead
+     * of an already-public URL.
+     */
+    private isFilesystemPath;
+    /**
+     * Applies post-processing for emitted production assets.
+     *
+     * @remarks
+     * Current optimization is intentionally conservative: only generated CSS and
+     * JavaScript files inside the app dist directory are gzipped.
+     */
+    private optimizeDependencies;
+    /**
+     * Returns the cached processed asset for a dependency key when available.
+     */
+    private getCachedAsset;
+    /**
+     * Stores one processed asset in the dependency cache.
+     */
+    private setCachedAsset;
+    /**
+     * Clears all cached processed assets.
+     */
+    clearCache(): void;
+    /**
+     * Removes cached assets that were produced from the given file path.
+     */
+    invalidateCacheForFile(filepath: string): void;
+    /**
+     * Creates a service prewired with the default core processors.
+     */
+    static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService;
+    /**
+     * Returns the processor registry owned by this service.
+     */
+    getRegistry(): ProcessorRegistry;
+}