@ecopages/core 0.2.0-alpha.8 → 0.2.1

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

@@ -1,85 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import { getAppBuildAdapter } from '../../../../../build/build-adapter.ts';
-import type { NodeModuleScriptAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-
-export class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScriptAsset> {
-	async process(dep: NodeModuleScriptAsset) {
-		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 bundlerOptions = this.getBundlerOptions(dep);
-
-			const filePath = await this.bundleScript({
-				entrypoint: modulePath,
-				outdir: outdir,
-				minify: this.isProduction,
-				naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : '[name]-[hash].[ext]'),
-				...bundlerOptions,
-			});
-
-			return {
-				filepath: filePath,
-				kind: dep.kind,
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-				excludeFromHtml: dep.excludeFromHtml,
-			};
-		});
-	}
-
-	private resolveModulePath(importPath: string, rootDir: string): string {
-		if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
-			return importPath;
-		}
-
-		try {
-			return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
-		} catch {
-			return this.resolveModulePathFallback(importPath, rootDir);
-		}
-	}
-
-	private resolveModulePathFallback(importPath: string, rootDir: string, maxDepth = 5): string {
-		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}'`);
-	}
-}

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

@@ -1,27 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
-
-export class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
-	async process(dep: ContentStylesheetAsset): Promise<ProcessedAsset> {
-		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 ? undefined : filepath,
-				content: dep.inline ? dep.content : undefined,
-				kind: 'stylesheet',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-			};
-		});
-	}
-}

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

@@ -1,80 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
-
-export class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
-	private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS = new Set(['.css', '.scss', '.sass', '.less']);
-
-	getStyleContent = (srcUrl: string): Buffer => {
-		return fileSystem.readFileAsBuffer(srcUrl);
-	};
-
-	private isProcessableStylesheet(filepath: string): boolean {
-		return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-	}
-
-	private async applyStylesheetProcessors(content: string, filepath: string): Promise<string> {
-		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: FileStylesheetAsset): Promise<ProcessedAsset> {
-		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.absolutePaths.srcDir, dep.filepath),
-			);
-			const outputBuffer = Buffer.from(processedContent);
-
-			if (!dep.inline) {
-				fileSystem.ensureDir(path.dirname(filepath));
-				fileSystem.write(filepath, outputBuffer);
-			}
-
-			return {
-				filepath: filepath,
-				content: dep.inline ? processedContent : undefined,
-				kind: 'stylesheet',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-			};
-		});
-	}
-}

package/src/services/assets/browser-bundle.service.ts

@@ -1,53 +0,0 @@
-import type { BuildOptions, BuildResult, BuildTranspileProfile } from '../../build/build-adapter.ts';
-import type { EcoBuildPlugin } from '../../build/build-types.ts';
-import { getAppBrowserBuildPlugins, getAppBuildExecutor, getTranspileOptions } from '../../build/build-adapter.ts';
-import { mergeEcoBuildPlugins } from '../../build/build-manifest.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-
-export type BrowserBundleOptions = Omit<BuildOptions, 'target' | 'format' | 'sourcemap'> & {
-	profile: BuildTranspileProfile;
-};
-
-export interface BrowserBundleExecutor {
-	bundle(options: BrowserBundleOptions): Promise<BuildResult>;
-}
-
-/**
- * App-owned boundary for browser-oriented bundle work.
- *
- * @remarks
- * This service owns the shared browser transpile defaults and ensures browser
- * builds always run through the app-owned executor rather than direct backend
- * calls scattered across HMR and asset processing paths.
- */
-export class BrowserBundleService implements BrowserBundleExecutor {
-	private readonly appConfig: EcoPagesAppConfig;
-
-	/**
-	 * Creates the browser bundle boundary for one finalized app instance.
-	 */
-	constructor(appConfig: EcoPagesAppConfig) {
-		this.appConfig = appConfig;
-	}
-
-	/**
-	 * Runs one browser-targeted build through the app-owned executor.
-	 *
-	 * @remarks
-	 * Browser defaults and app-owned browser build plugins are applied here so HMR
-	 * and runtime asset generation do not have to recreate that policy at each call
-	 * site.
-	 */
-	async bundle(options: BrowserBundleOptions): Promise<BuildResult> {
-		const { profile, ...rawBuildOptions } = options;
-		const buildOptions = rawBuildOptions as Omit<BuildOptions, 'target' | 'format' | 'sourcemap'>;
-		const plugins = buildOptions.plugins as EcoBuildPlugin[] | undefined;
-		const request = {
-			...buildOptions,
-			...getTranspileOptions(profile),
-			plugins: mergeEcoBuildPlugins(plugins, getAppBrowserBuildPlugins(this.appConfig)),
-		} as BuildOptions;
-
-		return await getAppBuildExecutor(this.appConfig).build(request);
-	}
-}

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

@@ -1,126 +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.ts

@@ -1,18 +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/memory-cache-store.ts

@@ -1,130 +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 class MemoryCacheStore implements CacheStore {
-	private cache = new Map<string, CacheEntry>();
-	private tagIndex = new Map<string, Set<string>>();
-	private readonly maxEntries: number;
-
-	constructor(options: MemoryCacheStoreOptions = {}) {
-		this.maxEntries = options.maxEntries ?? 1000;
-	}
-
-	/**
-	 * 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.
-	 */
-	async get(key: string): Promise<CacheEntry | null> {
-		const entry = this.cache.get(key);
-		if (!entry) return null;
-
-		this.cache.delete(key);
-		this.cache.set(key, entry);
-
-		return entry;
-	}
-
-	/**
-	 * 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.
-	 */
-	async set(key: string, entry: CacheEntry): Promise<void> {
-		const existingEntry = this.cache.get(key);
-
-		if (existingEntry) {
-			for (const tag of existingEntry.tags) {
-				this.tagIndex.get(tag)?.delete(key);
-				if (this.tagIndex.get(tag)?.size === 0) {
-					this.tagIndex.delete(tag);
-				}
-			}
-			this.cache.delete(key);
-		} else if (this.cache.size >= this.maxEntries) {
-			const oldestKey = this.cache.keys().next().value;
-			if (oldestKey) await this.delete(oldestKey);
-		}
-
-		this.cache.set(key, entry);
-
-		for (const tag of entry.tags) {
-			if (!this.tagIndex.has(tag)) {
-				this.tagIndex.set(tag, new Set());
-			}
-			this.tagIndex.get(tag)!.add(key);
-		}
-	}
-
-	/**
-	 * Delete an entry and clean up its tag index references.
-	 * Removes empty tag sets to prevent memory leaks from accumulated tags.
-	 */
-	async delete(key: string): Promise<boolean> {
-		const entry = this.cache.get(key);
-		if (!entry) return false;
-
-		for (const tag of entry.tags) {
-			this.tagIndex.get(tag)?.delete(key);
-			if (this.tagIndex.get(tag)?.size === 0) {
-				this.tagIndex.delete(tag);
-			}
-		}
-
-		return this.cache.delete(key);
-	}
-
-	async invalidateByTags(tags: string[]): Promise<number> {
-		let count = 0;
-		const keysToDelete = new Set<string>();
-
-		for (const tag of tags) {
-			const keys = this.tagIndex.get(tag);
-			if (keys) {
-				for (const key of keys) {
-					keysToDelete.add(key);
-				}
-			}
-		}
-
-		for (const key of keysToDelete) {
-			if (await this.delete(key)) count++;
-		}
-
-		return count;
-	}
-
-	async invalidateByPaths(paths: string[]): Promise<number> {
-		let count = 0;
-		for (const path of paths) {
-			if (await this.delete(path)) count++;
-		}
-		return count;
-	}
-
-	async clear(): Promise<void> {
-		this.cache.clear();
-		this.tagIndex.clear();
-	}
-
-	async stats(): Promise<CacheStats> {
-		return {
-			entries: this.cache.size,
-		};
-	}
-}