@ecopages/core 0.2.0-alpha.53 → 0.2.0-alpha.54

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

@@ -0,0 +1,270 @@
+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 '../../../../../types/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);
+		});
+
+		test('should probe file extensions for installed package subpaths', async () => {
+			existsMock = vi.fn(
+				(candidatePath: string) =>
+					candidatePath === '/test/project/node_modules/@ecopages/radiant/client/install-hydrator.js',
+			);
+			fileSystem.exists = existsMock;
+
+			const processor = new NodeModuleScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: '@ecopages/radiant/client/install-hydrator',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result).toBeDefined();
+			expect(existsMock).toHaveBeenCalledWith(
+				'/test/project/node_modules/@ecopages/radiant/client/install-hydrator.js',
+			);
+		});
+	});
+
+	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);
+		});
+
+		test('should resolve exported package subpaths when adapter resolution falls back', async () => {
+			const config = createMockConfig();
+			config.rootDir = '/Users/andeeplus/github/ecopages/apps/docs';
+			const processor = new NodeModuleScriptProcessor({ appConfig: config });
+			fileSystem.readFileAsBuffer = vi.fn().mockReturnValue(Buffer.from('hydrator bootstrap'));
+
+			const dep: NodeModuleScriptAsset = {
+				kind: 'script',
+				source: 'node-module',
+				importPath: '@ecopages/radiant/client/install-hydrator',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.inline).toBe(true);
+			expect(result.content).toBe('hydrator bootstrap');
+		});
+	});
+});

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

@@ -0,0 +1,145 @@
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileSystem } from '@ecopages/file-system';
+import { getAppBuildAdapter } from '../../../../../build/build-adapter.ts';
+import type { NodeModuleScriptAsset } from '../../assets.types.ts';
+import { BaseScriptProcessor } from '../base/base-script-processor.ts';
+
+/**
+ * Processes browser script assets whose entrypoint is referenced by package specifier.
+ *
+ * @remarks
+ * Resolution stays app-boundary-first: prefer the active build adapter, then fall back
+ * to ESM export-map resolution, and only then probe a small set of literal file paths.
+ */
+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,
+					packageRole: dep.packageRole,
+					bundledSourceFilepaths: dep.bundledSourceFilepaths,
+				};
+			}
+
+			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,
+				packageRole: dep.packageRole,
+				bundledSourceFilepaths: dep.bundledSourceFilepaths,
+			};
+		});
+	}
+
+	/**
+	 * Resolves a node-module script entry from the current app boundary.
+	 *
+	 * @remarks
+	 * The build adapter remains the primary resolution surface because Bun/native
+	 * host-owned builds may have a more accurate view of aliases and package
+	 * ownership than core does. The local fallback only runs when that adapter
+	 * resolution is unavailable.
+	 */
+	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);
+		}
+	}
+
+	/**
+	 * Resolves browser-owned script specifiers without relying on CommonJS resolution.
+	 *
+	 * @remarks
+	 * This path intentionally stays ESM-first because these assets are emitted as
+	 * browser scripts. We first ask Node's ESM resolver to evaluate the package
+	 * export map from the app boundary. If that still fails, we fall back to a
+	 * bounded filesystem probe so direct file installs and package subpaths like
+	 * `pkg/client/entry` still resolve when the export map does not cover them.
+	 */
+	private resolveModulePathFallback(importPath: string, rootDir: string, maxDepth = 5): string {
+		try {
+			return fileURLToPath(
+				import.meta.resolve(importPath, pathToFileURL(path.join(rootDir, 'package.json')).href),
+			);
+		} catch {}
+
+		let currentDir = rootDir;
+		let remainingDepth = maxDepth;
+
+		while (remainingDepth >= 0) {
+			for (const candidatePath of this.getFallbackCandidatePaths(currentDir, importPath)) {
+				if (fileSystem.exists(candidatePath)) {
+					return candidatePath;
+				}
+			}
+
+			const parentDir = path.dirname(currentDir);
+			if (parentDir === currentDir) {
+				break;
+			}
+
+			currentDir = parentDir;
+			remainingDepth -= 1;
+		}
+
+		throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
+	}
+
+	/**
+	 * Returns the file candidates we accept during the final literal filesystem probe.
+	 *
+	 * @remarks
+	 * This is intentionally small and browser-entry-oriented: direct files, common
+	 * JS extensions, and `index.*` entrypoints. If a package needs anything more
+	 * exotic, it should resolve through the adapter or ESM export-map path above.
+	 */
+	private getFallbackCandidatePaths(rootDir: string, importPath: string): string[] {
+		const moduleBasePath = path.join(rootDir, 'node_modules', importPath);
+
+		return [
+			moduleBasePath,
+			`${moduleBasePath}.js`,
+			`${moduleBasePath}.mjs`,
+			`${moduleBasePath}.cjs`,
+			path.join(moduleBasePath, 'index.js'),
+			path.join(moduleBasePath, 'index.mjs'),
+			path.join(moduleBasePath, 'index.cjs'),
+		];
+	}
+}

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

@@ -0,0 +1,261 @@
+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 '../../../../../types/internal-types';
+import type { ContentStylesheetAsset } from '../../assets.types';
+import { Processor } from '../../../../../plugins/processor.ts';
+
+function createMockConfig(processors = new Map<string, Processor>()): EcoPagesAppConfig {
+	return {
+		baseUrl: 'http://localhost:3000',
+		rootDir: '/test/project',
+		srcDir: 'src',
+		publicDir: 'public',
+		pagesDir: 'pages',
+		includesDir: 'includes',
+		layoutsDir: 'layouts',
+		distDir: '.eco/public',
+		workDir: '.eco',
+		templatesExt: [],
+		componentsDir: 'components',
+		robotsTxt: { preferences: { '*': [] } },
+		additionalWatchPaths: [],
+		defaultMetadata: { title: 'Test', description: 'Test' },
+		integrations: [],
+		integrationsDependencies: [],
+		absolutePaths: {
+			config: '/test/project/eco.config.ts',
+			componentsDir: '/test/project/src/components',
+			distDir: '/test/project/.eco/public',
+			workDir: '/test/project/.eco',
+			includesDir: '/test/project/src/includes',
+			layoutsDir: '/test/project/src/layouts',
+			pagesDir: '/test/project/src/pages',
+			projectDir: '/test/project',
+			publicDir: '/test/project/public',
+			srcDir: '/test/project/src',
+			htmlTemplatePath: '/test/project/src/html.tsx',
+			error404TemplatePath: '/test/project/src/404.tsx',
+		},
+		processors,
+		loaders: new Map(),
+		sourceTransforms: new Map(),
+	};
+}
+
+class TestStylesheetProcessor extends Processor {
+	readonly buildPlugins = undefined;
+	readonly plugins = undefined;
+
+	constructor() {
+		super({
+			name: 'bundled-css',
+			capabilities: [{ kind: 'stylesheet' }],
+		});
+	}
+
+	async setup(): Promise<void> {}
+
+	async teardown(): Promise<void> {}
+
+	async process(input: unknown): Promise<unknown> {
+		return typeof input === 'string' ? input.replace('red', 'green') : input;
+	}
+}
+
+describe('ContentStylesheetProcessor', () => {
+	let writeMock: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		writeMock = vi.spyOn(fileSystem, 'write').mockImplementation(() => {});
+		vi.spyOn(fileSystem, 'exists').mockImplementation(() => true);
+	});
+
+	afterEach(() => {
+		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');
+		});
+	});
+
+	describe('process - stylesheet processors', () => {
+		test('should apply configured stylesheet processors to bundled content', async () => {
+			const processors = new Map<string, Processor>([['bundled-css', new TestStylesheetProcessor()]]);
+			const processor = new ContentStylesheetProcessor({
+				appConfig: createMockConfig(processors),
+			});
+
+			const dep: ContentStylesheetAsset = {
+				kind: 'stylesheet',
+				source: 'content',
+				content: 'body { color: red; }',
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.content).toBe('body { color: green; }');
+		});
+	});
+});