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

package/src/adapters/shared/hmr-manager.dispatch.test.ts

@@ -1,220 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, test } from 'vitest';
-import { ConfigBuilder } from '../../config/config-builder.ts';
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../../hmr/hmr-strategy.ts';
-import type { ClientBridgeEvent } from '../../public-types.ts';
-import { HmrManager as BunHmrManager } from '../bun/hmr-manager.ts';
-import { NodeHmrManager } from '../node/node-hmr-manager.ts';
-
-class FakeHmrStrategy extends HmrStrategy {
-	readonly type: HmrStrategyType;
-	private readonly _matches: (filePath: string) => boolean;
-	private readonly _action: HmrAction;
-
-	constructor(type: HmrStrategyType, matchFn: (f: string) => boolean, action: HmrAction) {
-		super();
-		this.type = type;
-		this._matches = matchFn;
-		this._action = action;
-	}
-
-	matches(filePath: string): boolean {
-		return this._matches(filePath);
-	}
-
-	async process(_filePath: string): Promise<HmrAction> {
-		return this._action;
-	}
-}
-
-type BridgeSpy = {
-	broadcasts: ClientBridgeEvent[];
-	bridge: {
-		subscriberCount: number;
-		broadcast(event: ClientBridgeEvent): void;
-		subscribe(): void;
-		unsubscribe(): void;
-	};
-};
-
-function createBridgeSpy(): BridgeSpy {
-	const broadcasts: ClientBridgeEvent[] = [];
-	const bridge = {
-		subscriberCount: 0,
-		broadcast(event: ClientBridgeEvent) {
-			broadcasts.push(event);
-		},
-		subscribe() {},
-		unsubscribe() {},
-	};
-	return { broadcasts, bridge };
-}
-
-const tempRoots: string[] = [];
-
-function createTempRoot(prefix: string): string {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
-	tempRoots.push(root);
-	return root;
-}
-
-afterEach(() => {
-	for (const root of tempRoots.splice(0)) {
-		fs.rmSync(root, { recursive: true, force: true });
-	}
-});
-
-const runtimes = [
-	{
-		name: 'node',
-		async create(rootDir: string, bridgeSpy: BridgeSpy) {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new NodeHmrManager({ appConfig: config, bridge: bridgeSpy.bridge as any });
-		},
-	},
-	{
-		name: 'bun',
-		async create(rootDir: string, bridgeSpy: BridgeSpy) {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new BunHmrManager({ appConfig: config, bridge: bridgeSpy.bridge as any });
-		},
-	},
-] as const;
-
-describe.each(runtimes)('handleFileChange dispatch: $name', ({ create }) => {
-	test('CSS file change routes to DefaultHmrStrategy and broadcasts reload', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-css');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const cssFile = path.join(rootDir, 'src', 'styles', 'main.css');
-		await manager.handleFileChange(cssFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.equal(spy.broadcasts[0].type, 'reload');
-		assert.equal(spy.broadcasts[0].path, cssFile);
-
-		manager.stop();
-	});
-
-	test('HTML file change routes to DefaultHmrStrategy and broadcasts reload', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-html');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const htmlFile = path.join(rootDir, 'src', 'pages', 'index.html');
-		await manager.handleFileChange(htmlFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.equal(spy.broadcasts[0].type, 'reload');
-		assert.equal(spy.broadcasts[0].path, htmlFile);
-
-		manager.stop();
-	});
-
-	test('TS file with no registered entrypoints falls back to DefaultHmrStrategy reload', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-ts-fallback');
-		const srcDir = path.join(rootDir, 'src');
-		fs.mkdirSync(srcDir, { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const tsFile = path.join(srcDir, 'component.ts');
-		await manager.handleFileChange(tsFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.equal(spy.broadcasts[0].type, 'reload');
-
-		manager.stop();
-	});
-
-	test('broadcast:false suppresses events even when the strategy returns a broadcast action', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-no-broadcast');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const cssFile = path.join(rootDir, 'src', 'main.css');
-		await manager.handleFileChange(cssFile, { broadcast: false });
-
-		assert.equal(spy.broadcasts.length, 0);
-
-		manager.stop();
-	});
-
-	test('INTEGRATION strategy wins over DefaultHmrStrategy for matched files', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-integration-priority');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const customFile = path.join(rootDir, 'src', 'component.jsx');
-		const integrationEvent: ClientBridgeEvent = {
-			type: 'update',
-			path: '/assets/_hmr/component.js',
-			timestamp: 1,
-		};
-		manager.registerStrategy(
-			new FakeHmrStrategy(HmrStrategyType.INTEGRATION, (f) => f === customFile, {
-				type: 'broadcast',
-				events: [integrationEvent],
-			}),
-		);
-
-		await manager.handleFileChange(customFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.deepEqual(spy.broadcasts[0], integrationEvent);
-
-		manager.stop();
-	});
-
-	test('action.type none suppresses broadcast even when shouldBroadcast is true', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-none-action');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const customFile = path.join(rootDir, 'src', 'silent.ts');
-		manager.registerStrategy(
-			new FakeHmrStrategy(HmrStrategyType.INTEGRATION, (f) => f === customFile, { type: 'none' }),
-		);
-
-		await manager.handleFileChange(customFile);
-
-		assert.equal(spy.broadcasts.length, 0);
-
-		manager.stop();
-	});
-
-	test('all events returned by a strategy are each broadcast individually', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-multi-event');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const customFile = path.join(rootDir, 'src', 'multi.ts');
-		const events: ClientBridgeEvent[] = [
-			{ type: 'update', path: '/assets/_hmr/a.js', timestamp: 1 },
-			{ type: 'update', path: '/assets/_hmr/b.js', timestamp: 2 },
-		];
-		manager.registerStrategy(
-			new FakeHmrStrategy(HmrStrategyType.INTEGRATION, (f) => f === customFile, {
-				type: 'broadcast',
-				events,
-			}),
-		);
-
-		await manager.handleFileChange(customFile);
-
-		assert.equal(spy.broadcasts.length, 2);
-		assert.deepEqual(spy.broadcasts, events);
-
-		manager.stop();
-	});
-});

package/src/adapters/shared/render-context.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createRenderContext } from './render-context.ts';
-import type { IntegrationPlugin } from '../../plugins/integration-plugin.ts';
-import type { IntegrationRenderer } from '../../route-renderer/orchestration/integration-renderer.ts';
-import type { EcoFunctionComponent } from '../../public-types.ts';
-
-describe('createRenderContext', () => {
-	const RenderToResponse = vi.fn(() => Promise.resolve(new Response('rendered')));
-
-	const Renderer = {
-		name: '-renderer',
-		renderToResponse: RenderToResponse,
-	} as unknown as IntegrationRenderer;
-
-	const ExplicitRenderer = {
-		name: 'explicit-renderer',
-		renderToResponse: RenderToResponse,
-	} as unknown as IntegrationRenderer;
-
-	const InitializeRenderer = vi.fn(() => Renderer);
-
-	const Plugin = {
-		name: '-integration',
-		initializeRenderer: InitializeRenderer,
-	} as unknown as IntegrationPlugin;
-
-	const ExplicitInitializeRenderer = vi.fn(() => ExplicitRenderer);
-
-	const ExplicitPlugin = {
-		name: 'explicit-renderer',
-		initializeRenderer: ExplicitInitializeRenderer,
-	} as unknown as IntegrationPlugin;
-
-	const ViewFn = ((props: { foo: string }) => `<div>${props.foo}</div>`) as EcoFunctionComponent<
-		{ foo: string },
-		string
-	>;
-	ViewFn.config = {
-		__eco: {
-			id: 'test',
-			file: '/some/dir/-view.ts',
-			integration: '-integration',
-		},
-	};
-
-	const renderContext = createRenderContext({
-		integrations: [Plugin, ExplicitPlugin],
-	});
-
-	it('should create a render context with methods', () => {
-		expect(renderContext.render).toBeDefined();
-		expect(renderContext.renderPartial).toBeDefined();
-		expect(renderContext.json).toBeDefined();
-		expect(renderContext.html).toBeDefined();
-	});
-
-	describe('render', () => {
-		it('should call renderer.renderToResponse with partial: false', async () => {
-			RenderToResponse.mockClear();
-			InitializeRenderer.mockClear();
-			ExplicitInitializeRenderer.mockClear();
-			const props = { foo: 'bar' };
-			const options = { status: 201, headers: { 'X-Custom': '1' } };
-
-			const response = await renderContext.render(ViewFn, props, options);
-
-			expect(InitializeRenderer).toHaveBeenCalled();
-			expect(RenderToResponse).toHaveBeenCalledWith(ViewFn, props, {
-				partial: false,
-				status: 201,
-				headers: { 'X-Custom': '1' },
-			});
-			expect(response instanceof Response).toBe(true);
-		});
-
-		it('should throw if view integration is unknown', async () => {
-			const badViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
-			badViewFn.config = { __eco: { id: 'test', file: '/bad-view.ts', integration: 'unknown' } };
-			await expect(renderContext.render(badViewFn, {})).rejects.toThrow('No integration found for: unknown');
-		});
-
-		it('should throw if view integration is missing', async () => {
-			const badViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
-			badViewFn.config = { __eco: undefined };
-			await expect(renderContext.render(badViewFn, {})).rejects.toThrow('Cannot determine integration for view');
-		});
-
-		it('should prefer explicit config.integration over injected metadata', async () => {
-			RenderToResponse.mockClear();
-			InitializeRenderer.mockClear();
-			ExplicitInitializeRenderer.mockClear();
-
-			const explicitViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
-			explicitViewFn.config = {
-				integration: 'explicit-renderer',
-				__eco: { id: 'test', file: '/some/file.tsx', integration: '-integration' },
-			};
-
-			await renderContext.render(explicitViewFn, {});
-
-			expect(ExplicitInitializeRenderer).toHaveBeenCalled();
-			expect(InitializeRenderer).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('renderPartial', () => {
-		it('should call renderer.renderToResponse with partial: true', async () => {
-			RenderToResponse.mockClear();
-			const props = { foo: 'bar' };
-			const options = { status: 200 };
-
-			await renderContext.renderPartial(ViewFn, props, options);
-
-			expect(InitializeRenderer).toHaveBeenCalled();
-			expect(RenderToResponse).toHaveBeenCalledWith(ViewFn, props, {
-				partial: true,
-				status: 200,
-				headers: undefined,
-			});
-		});
-	});
-
-	describe('json', () => {
-		it('should return a JSON response', async () => {
-			const data = { hello: 'world' };
-			const response = renderContext.json(data);
-			expect(response.headers.get('Content-Type')).toContain('application/json');
-			expect(await response.json()).toEqual(data);
-		});
-
-		it('should support custom status and headers', async () => {
-			const response = renderContext.json({}, { status: 201, headers: { 'X-Test': 'true' } });
-			expect(response.status).toBe(201);
-			expect(response.headers.get('X-Test')).toBe('true');
-		});
-	});
-
-	describe('html', () => {
-		it('should return an HTML response', async () => {
-			const html = '<div>hello</div>';
-			const response = renderContext.html(html);
-			expect(response.headers.get('Content-Type')).toContain('text/html');
-			expect(await response.text()).toBe(html);
-		});
-	});
-});

package/src/adapters/shared/server-adapter.test.ts

@@ -1,77 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, test } from 'vitest';
-import { ConfigBuilder } from '../../config/config-builder.ts';
-import type { ServerAdapterResult } from '../abstract/server-adapter.ts';
-import { SharedServerAdapter } from './server-adapter.ts';
-
-const tempRoots: string[] = [];
-
-function createTempRoot(prefix: string): string {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
-	tempRoots.push(root);
-	return root;
-}
-
-afterEach(() => {
-	for (const root of tempRoots.splice(0)) {
-		fs.rmSync(root, { recursive: true, force: true });
-	}
-});
-
-class TestSharedServerAdapter extends SharedServerAdapter<any, ServerAdapterResult> {
-	public async initialize(): Promise<void> {}
-	public getServerOptions(): Record<string, never> {
-		return {};
-	}
-	public async buildStatic(): Promise<void> {}
-	public async createAdapter(): Promise<ServerAdapterResult> {
-		return {
-			getServerOptions: () => ({}),
-			buildStatic: async () => {},
-		};
-	}
-	public async handleRequest(request: Request): Promise<Response> {
-		return await this.handleSharedRequest(request, {
-			apiHandlers: [],
-			hmrManager: {
-				getRuntimePath: () => '',
-				getDistDir: () => this.hmrDir,
-			},
-		});
-	}
-
-	constructor(
-		private readonly hmrDir: string,
-		rootDir: string,
-	) {
-		super({
-			appConfig: { rootDir } as any,
-			runtimeOrigin: 'http://localhost:3000',
-			serveOptions: {},
-			options: {},
-		});
-	}
-}
-
-test('SharedServerAdapter serves /assets/_hmr files from the HMR manager directory', async () => {
-	const rootDir = createTempRoot('ecopages-shared-server-hmr-assets');
-	const config = await new ConfigBuilder().setRootDir(rootDir).build();
-	const hmrDir = path.join(config.absolutePaths.workDir, 'assets', '_hmr');
-	const assetPath = path.join(hmrDir, 'pages', 'react-content.js');
-	fs.mkdirSync(path.dirname(assetPath), { recursive: true });
-	fs.writeFileSync(assetPath, 'export default 1;', 'utf8');
-
-	const adapter = new TestSharedServerAdapter(hmrDir, rootDir);
-	const response = await adapter.handleRequest(new Request('http://localhost/assets/_hmr/pages/react-content.js'));
-
-	assert.equal(response.status, 200);
-	assert.equal(response.headers.get('Content-Type'), 'application/javascript');
-	assert.equal(await response.text(), 'export default 1;');
-	assert.equal(
-		fs.existsSync(path.join(config.absolutePaths.distDir, 'assets', '_hmr', 'pages', 'react-content.js')),
-		false,
-	);
-});

package/src/adapters/shared/server-route-handler.test.ts

@@ -1,110 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ServerRouteHandler } from './server-route-handler';
-import type { FSRouter } from '../../router/server/fs-router';
-import type { FileSystemResponseMatcher } from './fs-server-response-matcher';
-import type { IHmrManager } from '../../public-types';
-
-function createMockDependencies() {
-	const Router = {
-		match: vi.fn(() => null),
-	} as unknown as FSRouter;
-
-	const FileSystemResponseMatcher = {
-		handleMatch: vi.fn(() => Promise.resolve(new Response('Matched Content'))),
-		handleNoMatch: vi.fn(() => Promise.resolve(new Response('Not Found', { status: 404 }))),
-	} as unknown as FileSystemResponseMatcher;
-
-	const HmrManager = {
-		isEnabled: vi.fn(() => true),
-		broadcast: vi.fn(),
-	} as unknown as IHmrManager;
-
-	return {
-		Router,
-		FileSystemResponseMatcher,
-		HmrManager,
-	};
-}
-
-describe('ServerRouteHandler', () => {
-	describe('handleResponse', () => {
-		it('should delegate to fileSystemResponseMatcher when route matches', async () => {
-			const { Router, FileSystemResponseMatcher } = createMockDependencies();
-			const handler = new ServerRouteHandler({
-				router: Router,
-				fileSystemResponseMatcher: FileSystemResponseMatcher,
-			});
-
-			Router.match = vi.fn(
-				() =>
-					({
-						/* match */
-					}) as any,
-			);
-			const request = new Request('http://localhost/test');
-			const response = await handler.handleResponse(request);
-
-			expect(FileSystemResponseMatcher.handleMatch).toHaveBeenCalled();
-			expect(response.status).toBe(200);
-		});
-
-		it('should delegate to handleNoMatch when route does not match', async () => {
-			const { Router, FileSystemResponseMatcher } = createMockDependencies();
-			const handler = new ServerRouteHandler({
-				router: Router,
-				fileSystemResponseMatcher: FileSystemResponseMatcher,
-			});
-
-			const request = new Request('http://localhost/unknown');
-			const response = await handler.handleResponse(request);
-
-			expect(FileSystemResponseMatcher.handleNoMatch).toHaveBeenCalled();
-			expect(response.status).toBe(404);
-		});
-
-		it('should inject HMR script in watch mode for HTML responses', async () => {
-			const { Router, FileSystemResponseMatcher, HmrManager } = createMockDependencies();
-			const handler = new ServerRouteHandler({
-				router: Router,
-				fileSystemResponseMatcher: FileSystemResponseMatcher,
-				watch: true,
-				hmrManager: HmrManager,
-			});
-
-			Router.match = vi.fn(() => ({}) as any);
-			FileSystemResponseMatcher.handleMatch = vi.fn(() =>
-				Promise.resolve(
-					new Response('<html><body></body></html>', { headers: { 'Content-Type': 'text/html' } }),
-				),
-			);
-
-			const request = new Request('http://localhost/test');
-			const response = await handler.handleResponse(request);
-			const text = await response.text();
-
-			expect(text).toContain("import '/_hmr_runtime.js'");
-		});
-	});
-
-	describe('handleNoMatch', () => {
-		it('should broadcast error if handleNoMatch throws', async () => {
-			const { Router, FileSystemResponseMatcher, HmrManager } = createMockDependencies();
-			const handler = new ServerRouteHandler({
-				router: Router,
-				fileSystemResponseMatcher: FileSystemResponseMatcher,
-				watch: true,
-				hmrManager: HmrManager,
-			});
-
-			FileSystemResponseMatcher.handleNoMatch = vi.fn(() => {
-				throw new Error('Test Error');
-			});
-
-			const request = new Request('http://localhost/unknown');
-			const response = await handler.handleNoMatch(request);
-
-			expect(response.status).toBe(500);
-			expect(HmrManager.broadcast).toHaveBeenCalledWith({ type: 'error', message: 'Test Error' });
-		});
-	});
-});