@ecopages/core 0.2.0-alpha.5 → 0.2.0-alpha.7

package/src/services/asset-processing-service/processors/base/base-script-processor.js

@@ -1,80 +0,0 @@
-import { appLogger } from "../../../../global/app-logger";
-import { defaultBuildAdapter } from "../../../../build/build-adapter.js";
-import { fileSystem } from "@ecopages/file-system";
-import path from "node:path";
-import { BaseProcessor } from "./base-processor";
-class BaseScriptProcessor extends BaseProcessor {
-  constructor({ appConfig }) {
-    super({ appConfig });
-  }
-  shouldBundle(dep) {
-    return dep.bundle !== false;
-  }
-  getBundlerOptions(dep) {
-    return dep.bundleOptions || {};
-  }
-  collectBuildPlugins() {
-    const plugins = [];
-    if (this.appConfig.processors?.size) {
-      for (const processor of this.appConfig.processors.values()) {
-        if (processor.buildPlugins) {
-          plugins.push(...processor.buildPlugins);
-        }
-      }
-    }
-    if (this.appConfig.loaders?.size) {
-      plugins.push(...this.appConfig.loaders.values());
-    }
-    return plugins;
-  }
-  async bundleScript({
-    entrypoint,
-    outdir,
-    plugins: additionalPlugins,
-    ...rest
-  }) {
-    const buildPlugins = this.collectBuildPlugins();
-    const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
-    const build = await defaultBuildAdapter.build({
-      entrypoints: [entrypoint],
-      outdir,
-      root: this.appConfig.rootDir,
-      ...defaultBuildAdapter.getTranspileOptions("browser-script"),
-      splitting: true,
-      naming: "[name]-[hash].[ext]",
-      plugins: allPlugins,
-      ...rest
-    });
-    if (!build.success) {
-      for (const log of build.logs) {
-        appLogger.debug(log.message, log);
-      }
-    }
-    const entryBaseName = path.parse(entrypoint).name;
-    const entryOutput = build.outputs.map((output) => output.path).find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
-    if (entryOutput) {
-      return entryOutput;
-    }
-    const nonVendorOutput = build.outputs.map((output) => output.path).find((outputPath) => !path.basename(outputPath).startsWith("vendors"));
-    if (nonVendorOutput) {
-      return nonVendorOutput;
-    }
-    const primaryOutput = build.outputs[0]?.path;
-    if (primaryOutput) {
-      return primaryOutput;
-    }
-    const namedFallbackOutput = path.join(outdir, `${entryBaseName}.js`);
-    if (fileSystem.exists(namedFallbackOutput)) {
-      return namedFallbackOutput;
-    }
-    const fallbackOutput = path.join(outdir, "entry_0.js");
-    if (fileSystem.exists(fallbackOutput)) {
-      return fallbackOutput;
-    }
-    const logMessage = build.logs.map((log) => log.message).join(" | ");
-    throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ""}`);
-  }
-}
-export {
-  BaseScriptProcessor
-};

package/src/services/asset-processing-service/processors/index.d.ts

@@ -1,5 +0,0 @@
-export * from './script/content-script.processor';
-export * from './script/file-script.processor';
-export * from './script/node-module-script.processor';
-export * from './stylesheet/content-stylesheet.processor';
-export * from './stylesheet/file-stylesheet.processor';

package/src/services/asset-processing-service/processors/index.js

@@ -1,5 +0,0 @@
-export * from "./script/content-script.processor";
-export * from "./script/file-script.processor";
-export * from "./script/node-module-script.processor";
-export * from "./stylesheet/content-stylesheet.processor";
-export * from "./stylesheet/file-stylesheet.processor";

package/src/services/asset-processing-service/processors/script/content-script.processor.d.ts

@@ -1,5 +0,0 @@
-import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-export declare class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
-    process(dep: ContentScriptAsset): Promise<ProcessedAsset>;
-}

package/src/services/asset-processing-service/processors/script/content-script.processor.js

@@ -1,57 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor";
-class ContentScriptProcessor extends BaseScriptProcessor {
-  async process(dep) {
-    const hash = this.generateHash(dep.content);
-    const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
-    const shouldBundle = this.shouldBundle(dep);
-    const filepath = path.join(this.getAssetsDir(), "scripts", filename);
-    if (!shouldBundle) {
-      if (!dep.inline) fileSystem.write(filepath, dep.content);
-      const unbundledProcessedAsset = {
-        filepath,
-        content: dep.inline ? dep.content : void 0,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
-      };
-      this.writeCacheFile(filename, unbundledProcessedAsset);
-      return unbundledProcessedAsset;
-    }
-    if (dep.content) {
-      const tempDir = this.appConfig.absolutePaths.distDir;
-      fileSystem.ensureDir(tempDir);
-      const tempFileName = path.join(
-        tempDir,
-        `${path.parse(filename).name}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp.js`
-      );
-      fileSystem.write(tempFileName, dep.content);
-      const bundledFilePath = await this.bundleScript({
-        entrypoint: tempFileName,
-        outdir: this.getAssetsDir(),
-        minify: this.isProduction,
-        naming: `${path.parse(filename).name}-[hash].[ext]`,
-        ...this.getBundlerOptions(dep)
-      });
-      const processedAsset = {
-        filepath: bundledFilePath,
-        content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
-      };
-      fileSystem.remove(tempFileName);
-      this.writeCacheFile(filename, processedAsset);
-      return processedAsset;
-    }
-    throw new Error("No content found for script asset");
-  }
-}
-export {
-  ContentScriptProcessor
-};

package/src/services/asset-processing-service/processors/script/file-script.processor.d.ts

@@ -1,8 +0,0 @@
-import type { IHmrManager } from '../../../../internal-types';
-import type { FileScriptAsset, ProcessedAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-export declare class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
-    private hmrManager?;
-    setHmrManager(hmrManager: IHmrManager): void;
-    process(dep: FileScriptAsset): Promise<ProcessedAsset>;
-}

package/src/services/asset-processing-service/processors/script/file-script.processor.js

@@ -1,76 +0,0 @@
-import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../constants";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor";
-class FileScriptProcessor extends BaseScriptProcessor {
-  hmrManager;
-  setHmrManager(hmrManager) {
-    this.hmrManager = hmrManager;
-  }
-  async process(dep) {
-    if (this.hmrManager?.isEnabled() && !dep.inline) {
-      const outputUrl = await this.hmrManager.registerEntrypoint(dep.filepath);
-      return {
-        filepath: dep.filepath,
-        srcUrl: outputUrl,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: false,
-        excludeFromHtml: dep.excludeFromHtml
-      };
-    }
-    const content = fileSystem.readFileSync(dep.filepath);
-    const shouldBundle = this.shouldBundle(dep);
-    const configHash = this.generateHash(
-      JSON.stringify({
-        bundle: shouldBundle,
-        minify: shouldBundle && this.isProduction,
-        opts: dep.bundleOptions
-      })
-    );
-    const cachekey = `${this.buildCacheKey(dep.filepath, this.generateHash(content), dep)}:${configHash}`;
-    return this.getOrProcess(cachekey, async () => {
-      if (!shouldBundle) {
-        const outFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
-        let filepath;
-        if (!dep.inline) {
-          filepath = path.join(this.getAssetsDir(), outFilepath);
-          fileSystem.copyFile(dep.filepath, filepath);
-        }
-        return {
-          filepath,
-          content,
-          kind: "script",
-          position: dep.position,
-          attributes: dep.attributes,
-          inline: dep.inline,
-          excludeFromHtml: dep.excludeFromHtml
-        };
-      }
-      const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
-      const outdirPath = path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR, relativeFilepath);
-      const outdirDirname = path.dirname(outdirPath);
-      const bundlerOptions = this.getBundlerOptions(dep);
-      const bundledFilePath = await this.bundleScript({
-        entrypoint: dep.filepath,
-        outdir: outdirDirname,
-        minify: this.isProduction,
-        ...bundlerOptions,
-        plugins: bundlerOptions.plugins
-      });
-      return {
-        filepath: bundledFilePath,
-        content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
-      };
-    });
-  }
-}
-export {
-  FileScriptProcessor
-};

package/src/services/asset-processing-service/processors/script/node-module-script.processor.d.ts

@@ -1,7 +0,0 @@
-import type { NodeModuleScriptAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-export declare class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScriptAsset> {
-    process(dep: NodeModuleScriptAsset): Promise<import("../../assets.types").ProcessedAsset>;
-    private resolveModulePath;
-    private resolveModulePathFallback;
-}

package/src/services/asset-processing-service/processors/script/node-module-script.processor.js

@@ -1,74 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { defaultBuildAdapter } from "../../../../build/build-adapter.js";
-import { BaseScriptProcessor } from "../base/base-script-processor";
-class NodeModuleScriptProcessor extends BaseScriptProcessor {
-  async process(dep) {
-    const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
-    const moduleName = path.basename(modulePath);
-    const filename = dep.name ?? `nm-${moduleName}`;
-    const configHash = this.generateHash(
-      JSON.stringify({ inline: dep.inline, minify: !dep.inline && this.isProduction, opts: dep.bundleOptions })
-    );
-    const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
-    return this.getOrProcess(cachekey, async () => {
-      if (dep.inline) {
-        const content = fileSystem.readFileAsBuffer(modulePath).toString();
-        return {
-          content,
-          kind: dep.kind,
-          position: dep.position,
-          attributes: dep.attributes,
-          inline: true,
-          excludeFromHtml: dep.excludeFromHtml
-        };
-      }
-      const outdir = path.join(this.getAssetsDir(), "vendors");
-      const filePath = await this.bundleScript({
-        entrypoint: modulePath,
-        outdir,
-        minify: this.isProduction,
-        naming: dep.name ? `${dep.name}-[hash].[ext]` : "[name]-[hash].[ext]",
-        ...this.getBundlerOptions(dep)
-      });
-      return {
-        filepath: filePath,
-        kind: dep.kind,
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
-      };
-    });
-  }
-  resolveModulePath(importPath, rootDir) {
-    if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
-      return importPath;
-    }
-    try {
-      return defaultBuildAdapter.resolve(importPath, rootDir);
-    } catch {
-      return this.resolveModulePathFallback(importPath, rootDir);
-    }
-  }
-  resolveModulePathFallback(importPath, rootDir, maxDepth = 5) {
-    let currentDir = rootDir;
-    let remainingDepth = maxDepth;
-    while (remainingDepth >= 0) {
-      const modulePath = path.join(currentDir, "node_modules", importPath);
-      if (fileSystem.exists(modulePath)) {
-        return modulePath;
-      }
-      const parentDir = path.dirname(currentDir);
-      if (parentDir === currentDir) {
-        break;
-      }
-      currentDir = parentDir;
-      remainingDepth -= 1;
-    }
-    throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
-  }
-}
-export {
-  NodeModuleScriptProcessor
-};

package/src/services/asset-processing-service/processors/stylesheet/content-stylesheet.processor.d.ts

@@ -1,5 +0,0 @@
-import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
-export declare class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
-    process(dep: ContentStylesheetAsset): Promise<ProcessedAsset>;
-}

package/src/services/asset-processing-service/processors/stylesheet/content-stylesheet.processor.js

@@ -1,25 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor";
-class ContentStylesheetProcessor extends BaseProcessor {
-  async process(dep) {
-    const hash = this.generateHash(dep.content);
-    const filename = `style-${hash}.css`;
-    const cachekey = this.buildCacheKey(filename, hash, dep);
-    return this.getOrProcess(cachekey, () => {
-      const filepath = path.join(this.getAssetsDir(), "styles", filename);
-      if (!dep.inline) fileSystem.write(filepath, dep.content);
-      return {
-        filepath: dep.inline ? void 0 : filepath,
-        content: dep.inline ? dep.content : void 0,
-        kind: "stylesheet",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline
-      };
-    });
-  }
-}
-export {
-  ContentStylesheetProcessor
-};

package/src/services/asset-processing-service/processors/stylesheet/file-stylesheet.processor.d.ts

@@ -1,9 +0,0 @@
-import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
-export declare class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
-    getStyleContent: (srcUrl: string) => Buffer;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
-    process(dep: FileStylesheetAsset): Promise<ProcessedAsset>;
-}

package/src/services/asset-processing-service/processors/stylesheet/file-stylesheet.processor.js

@@ -1,63 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor";
-class FileStylesheetProcessor extends BaseProcessor {
-  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
-  getStyleContent = (srcUrl) => {
-    return fileSystem.readFileAsBuffer(srcUrl);
-  };
-  isProcessableStylesheet(filepath) {
-    return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-  }
-  async applyStylesheetProcessors(content, filepath) {
-    if (!this.isProcessableStylesheet(filepath)) {
-      return content;
-    }
-    let transformedContent = content;
-    for (const processor of this.appConfig.processors.values()) {
-      const hasCapabilities = processor.getAssetCapabilities().length > 0;
-      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
-        continue;
-      }
-      if (!processor.matchesFileFilter(filepath)) {
-        continue;
-      }
-      const result = await processor.process(transformedContent, filepath);
-      if (typeof result === "string") {
-        transformedContent = result;
-        continue;
-      }
-      if (result instanceof Buffer) {
-        transformedContent = result.toString();
-      }
-    }
-    return transformedContent;
-  }
-  async process(dep) {
-    const buffer = this.getStyleContent(dep.filepath);
-    const rawContent = buffer.toString();
-    const processedContent = await this.applyStylesheetProcessors(rawContent, dep.filepath);
-    const hash = this.generateHash(processedContent);
-    const cachekey = this.buildCacheKey(dep.filepath, hash, dep);
-    return this.getOrProcess(cachekey, () => {
-      const filepath = path.join(this.getAssetsDir(), path.relative(this.appConfig.srcDir, dep.filepath));
-      const outputBuffer = Buffer.from(processedContent);
-      if (!dep.inline) {
-        fileSystem.ensureDir(path.dirname(filepath));
-        fileSystem.write(filepath, outputBuffer);
-      }
-      return {
-        filepath,
-        content: dep.inline ? processedContent : void 0,
-        kind: "stylesheet",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline
-      };
-    });
-  }
-}
-export {
-  FileStylesheetProcessor
-};

package/src/services/cache/cache.types.d.ts

@@ -1,107 +0,0 @@
-/**
- * Cache types and interfaces for page caching and ISR
- * @module
- */
-/**
- * Result from rendering a page, including HTML and cache strategy.
- */
-export interface RenderResult {
-    html: string;
-    strategy: CacheStrategy;
-}
-/**
- * Render strategy configuration for pages.
- * - `'static'`: Render once, cache indefinitely
- * - `'dynamic'`: No caching, render on every request
- * - `{ revalidate, tags }`: Cache with time-based revalidation and optional tags
- */
-export type CacheStrategy = 'static' | 'dynamic' | {
-    /** Seconds until cache is considered stale */
-    revalidate: number;
-    /** Tags for on-demand invalidation */
-    tags?: string[];
-};
-/**
- * Cache entry stored in the cache store.
- */
-export interface CacheEntry {
-    /** The rendered HTML content */
-    html: string;
-    /** Timestamp when the entry was created */
-    createdAt: number;
-    /** Timestamp when the entry should be revalidated (null = never stale) */
-    revalidateAfter: number | null;
-    /** Tags associated with this entry for invalidation */
-    tags: string[];
-    /** The cache strategy used (for generating headers on HIT) */
-    strategy: CacheStrategy;
-}
-/**
- * Cache statistics for debugging and monitoring.
- */
-export interface CacheStats {
-    /** Number of entries in the cache */
-    entries: number;
-    /** Memory usage in bytes (if available) */
-    memoryUsage?: number;
-    /** Cache hit rate (if tracked) */
-    hitRate?: number;
-}
-/**
- * Abstract interface for cache storage backends.
- * Implementations must handle serialization/deserialization internally.
- */
-export interface CacheStore {
-    /** Retrieve an entry by key */
-    get(key: string): Promise<CacheEntry | null>;
-    /** Store an entry */
-    set(key: string, entry: CacheEntry): Promise<void>;
-    /** Delete a specific entry */
-    delete(key: string): Promise<boolean>;
-    /** Delete all entries matching any of the provided tags */
-    invalidateByTags(tags: string[]): Promise<number>;
-    /** Delete entries by exact path */
-    invalidateByPaths(paths: string[]): Promise<number>;
-    /** Clear all entries */
-    clear(): Promise<void>;
-    /** Get cache statistics (optional, for debugging) */
-    stats?(): Promise<CacheStats>;
-}
-/**
- * Configuration for the cache system.
- */
-export interface CacheConfig {
-    /**
-     * Cache store implementation.
-     * @default 'memory'
-     */
-    store?: 'memory' | CacheStore;
-    /**
-     * Default cache strategy for pages that don't specify one.
-     * @default 'static'
-     */
-    defaultStrategy?: CacheStrategy;
-    /**
-     * Whether caching is enabled.
-     * Automatically disabled in dev mode unless explicitly set.
-     * @default true (production), false (development)
-     */
-    enabled?: boolean;
-    /**
-     * Maximum number of entries in the memory cache before LRU eviction.
-     * Only applies when using the built-in memory store.
-     * @default 1000
-     */
-    maxEntries?: number;
-}
-/**
- * Result of a cache lookup operation.
- */
-export interface CacheResult {
-    /** The cached HTML content */
-    html: string;
-    /** Cache status for X-Cache header */
-    status: 'hit' | 'miss' | 'stale';
-    /** The cache strategy (for generating Cache-Control headers) */
-    strategy: CacheStrategy;
-}

package/src/services/cache/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Cache services exports
- * @module
- */
-export type { CacheConfig, CacheEntry, CacheResult, CacheStats, CacheStore, CacheStrategy, RenderResult, } from './cache.types.js';
-export { MemoryCacheStore, type MemoryCacheStoreOptions } from './memory-cache-store.js';
-export { getCacheControlHeader, PageCacheService, type PageCacheServiceOptions } from './page-cache-service.js';

package/src/services/cache/index.js

@@ -1,7 +0,0 @@
-import { MemoryCacheStore } from "./memory-cache-store.js";
-import { getCacheControlHeader, PageCacheService } from "./page-cache-service.js";
-export {
-  MemoryCacheStore,
-  PageCacheService,
-  getCacheControlHeader
-};

package/src/services/cache/memory-cache-store.d.ts

@@ -1,42 +0,0 @@
-/**
- * In-memory cache store with LRU eviction.
- * Suitable for single-instance deployments and development.
- * @module
- */
-import type { CacheEntry, CacheStats, CacheStore } from './cache.types.js';
-export interface MemoryCacheStoreOptions {
-    /** Maximum number of entries before LRU eviction. @default 1000 */
-    maxEntries?: number;
-}
-/**
- * Simple in-memory cache store with LRU eviction.
- * Uses Map insertion order for LRU tracking.
- */
-export declare class MemoryCacheStore implements CacheStore {
-    private cache;
-    private tagIndex;
-    private readonly maxEntries;
-    constructor(options?: MemoryCacheStoreOptions);
-    /**
-     * Retrieve an entry by key.
-     * Uses Map's insertion order for LRU tracking - accessed entries are
-     * deleted and re-inserted to move them to the "most recently used" position.
-     */
-    get(key: string): Promise<CacheEntry | null>;
-    /**
-     * Store an entry, evicting the oldest if at capacity.
-     * When maxEntries is reached and a new key is added, the first key in
-     * the Map (oldest/least-recently-used) is evicted to make room.
-     * Updating an existing key refreshes its LRU position.
-     */
-    set(key: string, entry: CacheEntry): Promise<void>;
-    /**
-     * Delete an entry and clean up its tag index references.
-     * Removes empty tag sets to prevent memory leaks from accumulated tags.
-     */
-    delete(key: string): Promise<boolean>;
-    invalidateByTags(tags: string[]): Promise<number>;
-    invalidateByPaths(paths: string[]): Promise<number>;
-    clear(): Promise<void>;
-    stats(): Promise<CacheStats>;
-}