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

package/src/services/module-loading/page-module-import.service.test.ts

@@ -1,253 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import assert from 'node:assert/strict';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, it } from 'vitest';
-import type { BuildResult } from '../../build/build-adapter.js';
-import { PageModuleImportService, type PageModuleImportDependencies } from './page-module-import.service.ts';
-
-function createBuildResult(overrides?: Partial<BuildResult>): BuildResult {
-	return {
-		success: true,
-		logs: [],
-		outputs: [],
-		...overrides,
-	};
-}
-
-function createFakeDependencies(): {
-	dependencies: PageModuleImportDependencies;
-	calls: {
-		hashFile: string[];
-		buildModule: Array<{
-			options: Parameters<PageModuleImportDependencies['buildModule']>[0];
-			buildExecutor: Parameters<PageModuleImportDependencies['buildModule']>[1];
-		}>;
-	};
-	setNextBuildResult(result: BuildResult): void;
-} {
-	const calls = {
-		hashFile: [] as string[],
-		buildModule: [] as Array<{
-			options: Parameters<PageModuleImportDependencies['buildModule']>[0];
-			buildExecutor: Parameters<PageModuleImportDependencies['buildModule']>[1];
-		}>,
-	};
-	let nextBuildResult = createBuildResult();
-
-	return {
-		dependencies: {
-			hashFile(filePath: string): string {
-				calls.hashFile.push(filePath);
-				return 'hash123';
-			},
-			async buildModule(options, buildExecutor): Promise<BuildResult> {
-				calls.buildModule.push({ options, buildExecutor });
-				return nextBuildResult;
-			},
-		},
-		calls,
-		setNextBuildResult(result: BuildResult): void {
-			nextBuildResult = result;
-		},
-	};
-}
-
-describe('PageModuleImportService', () => {
-	let service: PageModuleImportService;
-	let fakeDependencies: ReturnType<typeof createFakeDependencies>;
-
-	beforeEach(() => {
-		fakeDependencies = createFakeDependencies();
-		service = new PageModuleImportService(fakeDependencies.dependencies);
-	});
-
-	afterEach(() => {
-		service.clearImportCache();
-		delete process.env.NODE_ENV;
-	});
-
-	it('should import the transpiled output in node runtimes', async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-page-module-import-'));
-		const compiledOutput = join(tempDir, 'page-hash123.js');
-		writeFileSync(compiledOutput, 'export const value = 42; export default { ok: true };', 'utf8');
-		fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-		try {
-			const result = await service.importModule<{ default: { ok: boolean }; value: number }>({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: tempDir,
-			});
-
-			assert.deepEqual(result.default, { ok: true });
-			assert.equal(result.value, 42);
-			assert.deepEqual(fakeDependencies.calls.hashFile, ['/app/pages/page.tsx']);
-			assert.deepEqual(fakeDependencies.calls.buildModule, [
-				{
-					options: {
-						entrypoints: ['/app/pages/page.tsx'],
-						root: '/app',
-						outdir: tempDir,
-						target: 'node',
-						format: 'esm',
-						sourcemap: 'none',
-						splitting: true,
-						minify: false,
-						naming: 'page-hash123.js',
-						externalPackages: true,
-						plugins: undefined,
-					},
-					buildExecutor: undefined,
-				},
-			]);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should throw the provided transpile error when the build fails', async () => {
-		fakeDependencies.setNextBuildResult(
-			createBuildResult({
-				success: false,
-				logs: [{ message: 'Unexpected token' }],
-				outputs: [],
-			}),
-		);
-
-		await assert.rejects(
-			service.importModule({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: '/tmp/out',
-				transpileErrorMessage: (details) => `transpile failed: ${details}`,
-			}),
-			/transpile failed: Unexpected token/,
-		);
-	});
-
-	it('should keep a stable node module path in development for unchanged files', async () => {
-		process.env.NODE_ENV = 'development';
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-page-module-import-dev-'));
-		const compiledOutput = join(tempDir, 'page-hash123.js');
-		writeFileSync(compiledOutput, 'export default { ok: true };', 'utf8');
-		fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-		try {
-			await service.importModule({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: tempDir,
-			});
-
-			assert.equal(fakeDependencies.calls.buildModule.length, 1);
-			assert.equal(fakeDependencies.calls.buildModule[0]?.options.naming, 'page-hash123.js');
-			assert.equal(fakeDependencies.calls.buildModule[0]?.options.splitting, true);
-			assert.equal(fakeDependencies.calls.buildModule[0]?.options.externalPackages, true);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should allow callers to opt back into bundled node imports explicitly', async () => {
-		process.env.NODE_ENV = 'development';
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-page-module-import-bundled-'));
-		const compiledOutput = join(tempDir, 'page-hash123.js');
-		writeFileSync(compiledOutput, 'export default { ok: true };', 'utf8');
-		fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-		try {
-			await service.importModule({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: tempDir,
-				externalPackages: false,
-			});
-
-			assert.equal(fakeDependencies.calls.buildModule.length, 1);
-			assert.equal(fakeDependencies.calls.buildModule[0]?.options.externalPackages, false);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should allow callers to disable code splitting explicitly', async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-page-module-import-unsplit-'));
-		const compiledOutput = join(tempDir, 'page-hash123.js');
-		writeFileSync(compiledOutput, 'export default { ok: true };', 'utf8');
-		fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-		try {
-			await service.importModule({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: tempDir,
-				splitting: false,
-			});
-
-			assert.equal(fakeDependencies.calls.buildModule.length, 1);
-			assert.equal(fakeDependencies.calls.buildModule[0]?.options.splitting, false);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should reuse cached node modules across different output directories', async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-page-module-import-cache-'));
-		const compiledOutput = join(tempDir, 'page-hash123.js');
-		writeFileSync(compiledOutput, 'export default { ok: true };', 'utf8');
-		fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-		try {
-			const first = await service.importModule<{ default: { ok: boolean } }>({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: join(tempDir, 'meta'),
-			});
-
-			const second = await service.importModule<{ default: { ok: boolean } }>({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: join(tempDir, 'render'),
-			});
-
-			assert.deepEqual(first.default, { ok: true });
-			assert.deepEqual(second.default, { ok: true });
-			assert.equal(fakeDependencies.calls.buildModule.length, 1);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should reload the same node module path after development graph invalidation', async () => {
-		process.env.NODE_ENV = 'development';
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-page-module-import-invalidate-'));
-		const compiledOutput = join(tempDir, 'page-hash123.js');
-		writeFileSync(compiledOutput, 'export const version = 1; export default { ok: true };', 'utf8');
-		fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-		try {
-			const first = await service.importModule<{ version: number }>({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: tempDir,
-			});
-
-			writeFileSync(compiledOutput, 'export const version = 2; export default { ok: true };', 'utf8');
-			service.invalidateDevelopmentGraph();
-			fakeDependencies.setNextBuildResult(createBuildResult({ outputs: [{ path: compiledOutput }] }));
-
-			const second = await service.importModule<{ version: number }>({
-				filePath: '/app/pages/page.tsx',
-				rootDir: '/app',
-				outdir: tempDir,
-			});
-
-			assert.equal(first.version, 1);
-			assert.equal(second.version, 2);
-			assert.equal(fakeDependencies.calls.buildModule.length, 2);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-});

package/src/services/module-loading/server-loader.service.test.ts

@@ -1,161 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'vitest';
-import type { BuildResult } from '../../build/build-adapter.js';
-import {
-	TranspilerServerLoader,
-	type ServerLoaderDependencyFactory,
-	type ServerLoaderTranspilerDependency,
-} from './server-loader.service.ts';
-import type { ServerModuleTranspilerBootstrapArgs } from './server-module-transpiler.service.ts';
-
-function createBuildResult(): BuildResult {
-	return {
-		success: true,
-		logs: [],
-		outputs: [],
-	};
-}
-
-function createFakeTranspilerFactory(): {
-	factory: ServerLoaderDependencyFactory;
-	constructorArgs: ServerModuleTranspilerBootstrapArgs[];
-	importCalls: Array<unknown>;
-	invalidateCalls: Array<string[] | undefined>;
-	disposeCalls: number;
-	setNextImportResult(result: unknown): void;
-} {
-	const constructorArgs: ServerModuleTranspilerBootstrapArgs[] = [];
-	const importCalls: Array<unknown> = [];
-	const invalidateCalls: Array<string[] | undefined> = [];
-	let disposeCalls = 0;
-	let nextImportResult: unknown = undefined;
-
-	return {
-		factory: {
-			createTranspiler(context): ServerLoaderTranspilerDependency {
-				constructorArgs.push(context);
-
-				return {
-					async importModule<T = unknown>(
-						options: Parameters<ServerLoaderTranspilerDependency['importModule']>[0],
-					): Promise<T> {
-						importCalls.push(options);
-						return nextImportResult as T;
-					},
-					invalidate(changedFiles?: string[]): void {
-						invalidateCalls.push(changedFiles);
-					},
-					async dispose(): Promise<void> {
-						disposeCalls += 1;
-					},
-				};
-			},
-		},
-		constructorArgs,
-		importCalls,
-		invalidateCalls,
-		get disposeCalls() {
-			return disposeCalls;
-		},
-		setNextImportResult(result: unknown): void {
-			nextImportResult = result;
-		},
-	};
-}
-
-describe('TranspilerServerLoader', () => {
-	it('loads config through the bootstrap transpiler context', async () => {
-		const fakeFactory = createFakeTranspilerFactory();
-		const buildExecutor = { build: async () => createBuildResult() };
-		fakeFactory.setNextImportResult({ default: { ok: true } });
-
-		const loader = new TranspilerServerLoader(
-			{
-				rootDir: '/bootstrap-app',
-				getBuildExecutor: () => buildExecutor,
-			},
-			fakeFactory.factory,
-		);
-
-		await loader.loadConfig({
-			filePath: '/bootstrap-app/eco.config.ts',
-			outdir: '/bootstrap-app/.eco/.server-config',
-		});
-
-		assert.deepEqual(fakeFactory.constructorArgs, [
-			{
-				rootDir: '/bootstrap-app',
-				getBuildExecutor: fakeFactory.constructorArgs[0]?.getBuildExecutor,
-			},
-		]);
-		assert.deepEqual(fakeFactory.constructorArgs[0]?.getBuildExecutor(), buildExecutor);
-		assert.deepEqual(fakeFactory.importCalls, [
-			{
-				filePath: '/bootstrap-app/eco.config.ts',
-				outdir: '/bootstrap-app/.eco/.server-config',
-			},
-		]);
-	});
-
-	it('rebinding app context routes app loads through a new transpiler instance', async () => {
-		const fakeFactory = createFakeTranspilerFactory();
-		const bootstrapBuildExecutor = { build: async () => createBuildResult() };
-		const appBuildExecutor = { build: async () => createBuildResult() };
-		fakeFactory.setNextImportResult({});
-
-		const loader = new TranspilerServerLoader(
-			{
-				rootDir: '/bootstrap-app',
-				getBuildExecutor: () => bootstrapBuildExecutor,
-			},
-			fakeFactory.factory,
-		);
-
-		loader.rebindAppContext({
-			rootDir: '/app',
-			getBuildExecutor: () => appBuildExecutor,
-		});
-
-		await loader.loadApp({
-			filePath: '/app/app.ts',
-			outdir: '/app/.eco/.server-entry',
-		});
-
-		assert.equal(fakeFactory.constructorArgs.length, 2);
-		assert.equal(fakeFactory.constructorArgs[0]?.rootDir, '/bootstrap-app');
-		assert.equal(fakeFactory.constructorArgs[1]?.rootDir, '/app');
-		assert.deepEqual(fakeFactory.constructorArgs[0]?.getBuildExecutor(), bootstrapBuildExecutor);
-		assert.deepEqual(fakeFactory.constructorArgs[1]?.getBuildExecutor(), appBuildExecutor);
-		assert.deepEqual(fakeFactory.importCalls, [
-			{
-				filePath: '/app/app.ts',
-				outdir: '/app/.eco/.server-entry',
-			},
-		]);
-	});
-
-	it('forwards invalidate and dispose to owned transpiler instances', async () => {
-		const fakeFactory = createFakeTranspilerFactory();
-		const bootstrapBuildExecutor = { build: async () => createBuildResult() };
-		const appBuildExecutor = { build: async () => createBuildResult() };
-
-		const loader = new TranspilerServerLoader(
-			{
-				rootDir: '/bootstrap-app',
-				getBuildExecutor: () => bootstrapBuildExecutor,
-			},
-			fakeFactory.factory,
-		);
-
-		loader.rebindAppContext({
-			rootDir: '/app',
-			getBuildExecutor: () => appBuildExecutor,
-		});
-
-		loader.invalidate();
-		await loader.dispose();
-
-		assert.deepEqual(fakeFactory.invalidateCalls, [undefined, undefined]);
-		assert.equal(fakeFactory.disposeCalls, 2);
-	});
-});

package/src/services/module-loading/server-module-transpiler.service.test.ts

@@ -1,115 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'vitest';
-import type { BuildResult } from '../../build/build-adapter.js';
-import { ServerModuleTranspiler, type ServerModuleImportDependency } from './server-module-transpiler.service.ts';
-
-function createBuildResult(): BuildResult {
-	return {
-		success: true,
-		logs: [],
-		outputs: [],
-	};
-}
-
-function createFakeImportService(): {
-	dependency: ServerModuleImportDependency;
-	calls: {
-		importModule: Array<unknown>;
-		invalidateDevelopmentGraph: number;
-	};
-	setResult(result: unknown): void;
-} {
-	const calls = {
-		importModule: [] as Array<unknown>,
-		invalidateDevelopmentGraph: 0,
-	};
-	let nextResult: unknown = undefined;
-
-	return {
-		dependency: {
-			async importModule<T = unknown>(
-				options: Parameters<ServerModuleImportDependency['importModule']>[0],
-			): Promise<T> {
-				calls.importModule.push(options);
-				return nextResult as T;
-			},
-			invalidateDevelopmentGraph(): void {
-				calls.invalidateDevelopmentGraph += 1;
-			},
-		},
-		calls,
-		setResult(result: unknown): void {
-			nextResult = result;
-		},
-	};
-}
-
-describe('ServerModuleTranspiler', () => {
-	it('injects app root dir and build executor into page module imports', async () => {
-		const buildExecutor = { build: async () => createBuildResult() };
-		const fakeImportService = createFakeImportService();
-		fakeImportService.setResult({ default: { ok: true } });
-
-		const service = new ServerModuleTranspiler({
-			rootDir: '/app',
-			getBuildExecutor: () => buildExecutor,
-			pageModuleImportService: fakeImportService.dependency,
-		});
-
-		await service.importModule({
-			filePath: '/app/src/pages/index.tsx',
-			outdir: '/app/.eco/.server-modules',
-		});
-
-		assert.deepEqual(fakeImportService.calls.importModule, [
-			{
-				filePath: '/app/src/pages/index.tsx',
-				outdir: '/app/.eco/.server-modules',
-				rootDir: '/app',
-				buildExecutor,
-				invalidationVersion: undefined,
-			},
-		]);
-	});
-
-	it('supports explicit bootstrap root and executor without a full app config', async () => {
-		const buildExecutor = { build: async () => createBuildResult() };
-		const fakeImportService = createFakeImportService();
-		fakeImportService.setResult({ default: { ok: true } });
-
-		const service = new ServerModuleTranspiler({
-			rootDir: '/bootstrap-app',
-			getBuildExecutor: () => buildExecutor,
-			pageModuleImportService: fakeImportService.dependency,
-		});
-
-		await service.importModule({
-			filePath: '/bootstrap-app/eco.config.ts',
-			outdir: '/bootstrap-app/.eco/.server-modules',
-		});
-
-		assert.deepEqual(fakeImportService.calls.importModule, [
-			{
-				filePath: '/bootstrap-app/eco.config.ts',
-				outdir: '/bootstrap-app/.eco/.server-modules',
-				rootDir: '/bootstrap-app',
-				buildExecutor,
-				invalidationVersion: undefined,
-			},
-		]);
-	});
-
-	it('invalidates the owned import graph when no app invalidation callback is provided', () => {
-		const fakeImportService = createFakeImportService();
-
-		const service = new ServerModuleTranspiler({
-			rootDir: '/bootstrap-app',
-			getBuildExecutor: () => ({ build: async () => createBuildResult() }),
-			pageModuleImportService: fakeImportService.dependency,
-		});
-
-		service.invalidate(['/bootstrap-app/src/pages/index.tsx']);
-
-		assert.equal(fakeImportService.calls.invalidateDevelopmentGraph, 1);
-	});
-});

package/src/services/runtime-manifest/node-runtime-manifest.service.test.ts

@@ -1,95 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { test } from 'vitest';
-import {
-	createNodeRuntimeManifest,
-	getNodeRuntimeManifestPath,
-	getAppNodeRuntimeManifest,
-	setAppNodeRuntimeManifest,
-	writeAppNodeRuntimeManifest,
-} from './node-runtime-manifest.service.ts';
-
-test('createNodeRuntimeManifest summarizes app-owned runtime bootstrap state', () => {
-	const appConfig = {
-		rootDir: '/repo',
-		absolutePaths: {
-			config: '/repo/eco.config.ts',
-			srcDir: '/repo/src',
-			distDir: '/repo/dist',
-			workDir: '/repo/.eco',
-		},
-		loaders: new Map(),
-		runtime: {},
-	} as any;
-
-	const manifest = createNodeRuntimeManifest(appConfig, {
-		entryModulePath: '/repo/app.ts',
-	});
-
-	assert.deepEqual(manifest, {
-		runtime: 'node',
-		appRootDir: '/repo',
-		sourceRootDir: '/repo/src',
-		distDir: '/repo/dist',
-		workDir: '/repo/.eco',
-		modulePaths: {
-			config: '/repo/eco.config.ts',
-			entry: '/repo/app.ts',
-		},
-	});
-});
-
-test('getAppNodeRuntimeManifest falls back to a derived manifest and can be overridden', () => {
-	const appConfig = {
-		rootDir: '/repo',
-		absolutePaths: {
-			config: '/repo/eco.config.ts',
-			srcDir: '/repo/src',
-			distDir: '/repo/dist',
-			workDir: '/repo/.eco',
-		},
-		loaders: new Map(),
-		runtime: {},
-	} as any;
-
-	const derivedManifest = getAppNodeRuntimeManifest(appConfig);
-	assert.equal(derivedManifest.modulePaths.config, '/repo/eco.config.ts');
-	assert.equal(derivedManifest.modulePaths.entry, undefined);
-
-	const overriddenManifest = createNodeRuntimeManifest(appConfig, {
-		entryModulePath: '/repo/custom-entry.ts',
-	});
-	setAppNodeRuntimeManifest(appConfig, overriddenManifest);
-
-	assert.deepEqual(getAppNodeRuntimeManifest(appConfig), overriddenManifest);
-});
-
-test('writeAppNodeRuntimeManifest persists the app-owned manifest to the runtime file boundary', () => {
-	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-runtime-manifest-'));
-	const appConfig = {
-		rootDir,
-		absolutePaths: {
-			config: path.join(rootDir, 'eco.config.ts'),
-			srcDir: path.join(rootDir, 'src'),
-			distDir: path.join(rootDir, 'dist'),
-			workDir: path.join(rootDir, '.eco'),
-		},
-		loaders: new Map(),
-		runtime: {},
-	} as any;
-
-	try {
-		const result = writeAppNodeRuntimeManifest(appConfig, {
-			entryModulePath: path.join(rootDir, 'app.ts'),
-		});
-
-		assert.equal(result.manifestFilePath, getNodeRuntimeManifestPath(appConfig));
-		assert.equal(fs.existsSync(result.manifestFilePath), true);
-		assert.deepEqual(JSON.parse(fs.readFileSync(result.manifestFilePath, 'utf8')), result.manifest);
-		assert.equal(result.manifest.modulePaths.entry, path.join(rootDir, 'app.ts'));
-	} finally {
-		fs.rmSync(rootDir, { recursive: true, force: true });
-	}
-});