@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

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

@@ -0,0 +1,227 @@
+import { describe, expect, test, beforeEach, afterEach, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
+import { NodeModuleScriptProcessor } from './node-module-script.processor';
+import type { EcoPagesAppConfig } from '../../../../../internal-types';
+import type { NodeModuleScriptAsset } from '../../assets.types';
+
+const originalExists = fileSystem.exists;
+const originalReadFileAsBuffer = fileSystem.readFileAsBuffer;
+
+const createMockConfig = (): EcoPagesAppConfig =>
+	({
+		rootDir: '/test/project',
+		srcDir: 'src',
+		distDir: '.eco/public',
+		absolutePaths: {
+			distDir: '/test/project/.eco/public',
+			srcDir: '/test/project/src',
+		},
+		processors: new Map(),
+		loaders: new Map(),
+	}) as unknown as EcoPagesAppConfig;
+
+describe('NodeModuleScriptProcessor', () => {
+	let existsMock: any;
+	let readFileAsBufferMock: any;
+
+	beforeEach(() => {
+		existsMock = vi.fn(() => true);
+		readFileAsBufferMock = vi.fn(() => Buffer.from('// module content'));
+		fileSystem.exists = existsMock;
+		fileSystem.readFileAsBuffer = readFileAsBufferMock;
+	});
+
+	afterEach(() => {
+		fileSystem.exists = originalExists;
+		fileSystem.readFileAsBuffer = originalReadFileAsBuffer;
+		vi.restoreAllMocks();
+	});
+
+	describe('process - inline module', () => {
+		test('should return inline content for inline modules', async () => {
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'some-package/dist/index.js',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.inline).toBe(true);
+			expect(result.content).toBe('// module content');
+			expect(result.kind).toBe('script');
+		});
+
+		test('should preserve attributes for inline modules', async () => {
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'some-package/dist/index.js',
+				inline: true,
+				attributes: { type: 'module' },
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.attributes).toEqual({ type: 'module' });
+		});
+
+		test('should preserve position for inline modules', async () => {
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'some-package/dist/index.js',
+				inline: true,
+				position: 'head',
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.position).toBe('head');
+		});
+	});
+
+	describe('process - caching', () => {
+		test('should return cached result on subsequent calls', async () => {
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'cached-package/dist/index.js',
+				inline: true,
+			};
+
+			const result1 = await processor.process(dep);
+			const result2 = await processor.process(dep);
+
+			expect(readFileAsBufferMock.mock.calls.length).toBe(1);
+			expect(result1).toEqual(result2);
+		});
+	});
+
+	describe('resolveModulePath', () => {
+		test('should throw error when module not found', async () => {
+			existsMock = vi.fn(() => false);
+			fileSystem.exists = existsMock;
+
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'non-existent-package/index.js',
+				inline: true,
+			};
+
+			await expect(processor.process(dep)).rejects.toThrow(/Could not resolve module/);
+		});
+
+		test('should find module in parent directories', async () => {
+			let callCount = 0;
+			existsMock = vi.fn((_path: string) => {
+				callCount++;
+				return callCount >= 3;
+			});
+			fileSystem.exists = existsMock;
+
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'parent-package/index.js',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result).toBeDefined();
+			expect(callCount).toBeGreaterThanOrEqual(3);
+		});
+	});
+
+	describe('process - custom name', () => {
+		test('should use custom name when provided', async () => {
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'some-package/dist/index.js',
+				name: 'custom-vendor',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result).toBeDefined();
+			expect(result.inline).toBe(true);
+		});
+
+		test('should preserve explicit bundle naming when provided', async () => {
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+			const bundleScriptSpy = vi
+				.spyOn(
+					processor as unknown as { bundleScript: (options: Record<string, unknown>) => Promise<string> },
+					'bundleScript',
+				)
+				.mockResolvedValue('/test/project/.eco/public/assets/vendors/react.development.js');
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: 'react',
+				name: 'react',
+				inline: false,
+				bundleOptions: {
+					naming: 'react.development.js',
+				},
+			};
+
+			const result = await processor.process(dep);
+
+			expect(bundleScriptSpy).toHaveBeenCalledWith(
+				expect.objectContaining({
+					naming: 'react.development.js',
+				}),
+			);
+			expect(result.filepath).toBe('/test/project/.eco/public/assets/vendors/react.development.js');
+		});
+	});
+
+	describe('resolveModulePath with real dependencies', () => {
+		beforeEach(() => {
+			fileSystem.exists = originalExists;
+			fileSystem.readFileAsBuffer = originalReadFileAsBuffer;
+		});
+
+		test('should resolve @ecopages/logger using Bun.resolveSync', async () => {
+			const config = createMockConfig();
+			config.rootDir = process.cwd();
+			const processor = new NodeModuleScriptProcessor({ appConfig: config });
+			fileSystem.readFileAsBuffer = vi.fn().mockResolvedValue(Buffer.from('dummy content'));
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: '@ecopages/logger',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result).toBeDefined();
+			expect(result.inline).toBe(true);
+			expect(result.content).toBeDefined();
+			expect(result.content!.length).toBeGreaterThan(0);
+		});
+	});
+});

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

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { fileSystem } from '@ecopages/file-system';
-import { defaultBuildAdapter } from '../../../../build/build-adapter.ts';
+import { getAppBuildAdapter } from '../../../../../build/build-adapter.ts';
 import type { NodeModuleScriptAsset } from '../../assets.types';
 import { BaseScriptProcessor } from '../base/base-script-processor';
 
@@ -28,13 +28,14 @@ export class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScr
 			}
 
 			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: dep.name ? `${dep.name}-[hash].[ext]` : '[name]-[hash].[ext]',
-				...this.getBundlerOptions(dep),
+				naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : '[name]-[hash].[ext]'),
+				...bundlerOptions,
 			});
 
 			return {
@@ -54,7 +55,7 @@ export class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScr
 		}
 
 		try {
-			return defaultBuildAdapter.resolve(importPath, rootDir);
+			return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
 		} catch {
 			return this.resolveModulePathFallback(importPath, rootDir);
 		}

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

@@ -0,0 +1,199 @@
+import { describe, expect, test, beforeEach, afterEach, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
+import { ContentStylesheetProcessor } from './content-stylesheet.processor';
+import type { EcoPagesAppConfig } from '../../../../../internal-types';
+import type { ContentStylesheetAsset } from '../../assets.types';
+
+const originalWrite = fileSystem.write;
+const originalExists = fileSystem.exists;
+
+const createMockConfig = (): EcoPagesAppConfig =>
+	({
+		rootDir: '/test/project',
+		srcDir: 'src',
+		distDir: '.eco/public',
+		absolutePaths: {
+			distDir: '/test/project/.eco/public',
+			srcDir: '/test/project/src',
+		},
+	}) as unknown as EcoPagesAppConfig;
+
+describe('ContentStylesheetProcessor', () => {
+	let writeMock: any;
+
+	beforeEach(() => {
+		writeMock = vi.fn(() => {});
+		fileSystem.write = writeMock;
+		fileSystem.exists = vi.fn(() => true);
+	});
+
+	afterEach(() => {
+		fileSystem.write = originalWrite;
+		fileSystem.exists = originalExists;
+		vi.restoreAllMocks();
+	});
+
+	describe('process - file-based stylesheet', () => {
+		test('should write stylesheet file when not inline', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: 'body { color: red; }',
+				inline: false,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(writeMock).toHaveBeenCalled();
+			expect(result.filepath).toBeDefined();
+			expect(result.filepath).toContain('style-');
+			expect(result.filepath).toContain('.css');
+			expect(result.kind).toBe('stylesheet');
+			expect(result.inline).toBe(false);
+			expect(result.content).toBeUndefined();
+		});
+
+		test('should include hash in filename', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: 'body { color: blue; }',
+				inline: false,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.filepath).toMatch(/style-\d+\.css$/);
+		});
+	});
+
+	describe('process - inline stylesheet', () => {
+		test('should return content without writing file when inline', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.inline { display: flex; }',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(writeMock).not.toHaveBeenCalled();
+			expect(result.inline).toBe(true);
+			expect(result.content).toBe('.inline { display: flex; }');
+			expect(result.filepath).toBeUndefined();
+		});
+	});
+
+	describe('process - caching', () => {
+		test('should return cached result on subsequent calls', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.cached { margin: 0; }',
+				inline: false,
+			};
+
+			const result1 = await processor.process(dep);
+			const result2 = await processor.process(dep);
+
+			expect(writeMock.mock.calls.length).toBe(1);
+			expect(result1).toEqual(result2);
+		});
+
+		test('should use different cache keys for different content', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep1: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.first { padding: 10px; }',
+				inline: false,
+			};
+
+			const dep2: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.second { padding: 20px; }',
+				inline: false,
+			};
+
+			await processor.process(dep1);
+			await processor.process(dep2);
+
+			expect(writeMock.mock.calls.length).toBe(2);
+		});
+	});
+
+	describe('process - attributes and position', () => {
+		test('should preserve attributes from dependency', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.styled { color: green; }',
+				inline: true,
+				attributes: { 'data-theme': 'dark' },
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.attributes).toEqual({ 'data-theme': 'dark' });
+		});
+
+		test('should preserve position from dependency', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.head-style { font-size: 16px; }',
+				inline: true,
+				position: 'head',
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.position).toBe('head');
+		});
+
+		test('should return updated attributes when cached asset is retrieved with different attributes', async () => {
+			const processor = new ContentStylesheetProcessor({ appConfig: createMockConfig() });
+
+			const depWithMedia: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.cached-style { color: red; }',
+				inline: false,
+				attributes: { media: 'screen' },
+				position: 'head',
+			};
+
+			const depWithPrint: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: '.cached-style { color: red; }',
+				inline: false,
+				attributes: { media: 'print' },
+				position: 'body',
+			};
+
+			const result1 = await processor.process(depWithMedia);
+			const result2 = await processor.process(depWithPrint);
+
+			expect(result1.attributes).toEqual({ media: 'screen' });
+			expect(result1.position).toBe('head');
+			expect(result2.attributes).toEqual({ media: 'print' });
+			expect(result2.position).toBe('body');
+		});
+	});
+});

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

@@ -56,7 +56,10 @@ export class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset>
 		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 filepath = path.join(
+				this.getAssetsDir(),
+				path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath),
+			);
 			const outputBuffer = Buffer.from(processedContent);
 
 			if (!dep.inline) {

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

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from 'vitest';
+import { BrowserBundleService } from './browser-bundle.service.ts';
+
+describe('BrowserBundleService', () => {
+	it('routes browser bundle requests through the app executor with profile defaults', async () => {
+		const build = vi.fn(async () => ({
+			success: true,
+			logs: [],
+			outputs: [{ path: '/tmp/out/entry.js' }],
+		}));
+		const service = new BrowserBundleService({
+			runtime: {
+				buildExecutor: { build },
+			},
+			loaders: new Map(),
+		} as any);
+
+		await service.bundle({
+			profile: 'browser-script',
+			entrypoints: ['/tmp/entry.ts'],
+			outdir: '/tmp/out',
+			minify: false,
+			naming: '[name].js',
+		});
+
+		expect(build).toHaveBeenCalledWith(
+			expect.objectContaining({
+				entrypoints: ['/tmp/entry.ts'],
+				outdir: '/tmp/out',
+				target: 'browser',
+				format: 'esm',
+				sourcemap: 'none',
+			}),
+		);
+	});
+});

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

@@ -0,0 +1,53 @@
+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/index.ts

@@ -11,8 +11,8 @@ export type {
 	CacheStore,
 	CacheStrategy,
 	RenderResult,
-} from './cache.types.ts';
+} from './cache.types.js';
 
-export { MemoryCacheStore, type MemoryCacheStoreOptions } from './memory-cache-store.ts';
+export { MemoryCacheStore, type MemoryCacheStoreOptions } from './memory-cache-store.js';
 
-export { getCacheControlHeader, PageCacheService, type PageCacheServiceOptions } from './page-cache-service.ts';
+export { getCacheControlHeader, PageCacheService, type PageCacheServiceOptions } from './page-cache-service.js';