@ecopages/core 0.2.0-alpha.22 → 0.2.0-alpha.24

package/src/config/config-builder.typecheck.test.ts

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { describe, expect, test } from 'vitest';
+
+type PackageManifest = {
+	name?: string;
+	private?: boolean;
+	dependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+};
+
+function readManifest(relativePath: string): PackageManifest {
+	const manifestPath = path.resolve(import.meta.dirname, '../../../..', relativePath);
+	return JSON.parse(readFileSync(manifestPath, 'utf-8')) as PackageManifest;
+}
+
+function resolveRepoPath(relativePath: string): string {
+	return path.resolve(import.meta.dirname, '../../../..', relativePath);
+}
+
+function collectPackageManifestPaths(relativeDir: string): string[] {
+	const dirPath = resolveRepoPath(relativeDir);
+	if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) {
+		return [];
+	}
+
+	return readdirSync(dirPath, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => path.posix.join(relativeDir, entry.name, 'package.json'))
+		.filter((manifestPath) => existsSync(resolveRepoPath(manifestPath)));
+}
+
+function collectCorePeerPackagePaths(): string[] {
+	const packagePaths = [
+		...collectPackageManifestPaths('packages/integrations'),
+		...collectPackageManifestPaths('packages/processors'),
+		'packages/browser-router/package.json',
+		'packages/react-router/package.json',
+	];
+
+	return packagePaths.filter((packagePath) => {
+		const manifest = readManifest(packagePath);
+		return manifest.name?.startsWith('@ecopages/') && !manifest.private;
+	});
+}
+
+function collectTypeScriptFiles(dirPath: string): string[] {
+	const results: string[] = [];
+
+	const visit = (currentPath: string): void => {
+		for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+			const fullPath = path.join(currentPath, entry.name);
+			if (entry.isDirectory()) {
+				visit(fullPath);
+				continue;
+			}
+
+			if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+				results.push(fullPath);
+			}
+		}
+	};
+
+	visit(dirPath);
+	return results;
+}
+
+describe('ConfigBuilder published package compatibility', () => {
+	test('public integrations and processors peer @ecopages/core', () => {
+		const packages = collectCorePeerPackagePaths();
+		expect(packages.length).toBeGreaterThan(0);
+
+		for (const packagePath of packages) {
+			const manifest = readManifest(packagePath);
+			expect(manifest.peerDependencies?.['@ecopages/core'], packagePath).toBeDefined();
+			expect(manifest.dependencies?.['@ecopages/core'], packagePath).toBeUndefined();
+		}
+	});
+
+	test('built npm artifacts do not ship raw TypeScript sources', () => {
+		const distDirs = [
+			'packages/core/dist',
+			'packages/integrations/react/dist',
+			'packages/processors/postcss-processor/dist',
+		];
+
+		for (const relativeDistDir of distDirs) {
+			const distDir = resolveRepoPath(relativeDistDir);
+			if (!existsSync(distDir) || !statSync(distDir).isDirectory()) {
+				continue;
+			}
+
+			expect(collectTypeScriptFiles(distDir), relativeDistDir).toEqual([]);
+		}
+	});
+});

package/src/config/{constants.d.ts → constants.ts}

@@ -2,38 +2,47 @@
  * This file contains constants used throughout the project.
  * @module constants
  **/
+
 /**
  * Collection of status messages used in the application.
  */
-export declare const STATUS_MESSAGE: {
-    404: string;
+export const STATUS_MESSAGE = {
+	404: '404 Not Found',
 };
+
 /**
  *Variables used to determine if the app is running on Bun
  */
-export declare const IS_BUN: boolean;
+export const IS_BUN = typeof Bun !== 'undefined';
+
 /**
  * Directory used for storing assets.
  */
-export declare const RESOLVED_ASSETS_DIR = "assets";
+export const RESOLVED_ASSETS_DIR = 'assets';
+
 /**
  * Directory used for storing vendor assets.
  * This is a subdirectory of the assets directory.
  */
-export declare const RESOLVED_ASSETS_VENDORS_DIR: string;
+export const RESOLVED_ASSETS_VENDORS_DIR: string = `${RESOLVED_ASSETS_DIR}/vendors`;
+
 /**
  * Base paths for generated project files.
  */
-export declare const GENERATED_BASE_PATHS: {
-    readonly types: "node_modules/@types";
-    readonly cache: "cache";
-};
-export declare const DEFAULT_ECOPAGES_PORT = 3000;
-export declare const DEFAULT_ECOPAGES_HOSTNAME = "localhost";
+export const GENERATED_BASE_PATHS = {
+	types: 'node_modules/@types',
+	cache: 'cache',
+} as const;
+
+export const DEFAULT_ECOPAGES_PORT = 3000;
+
+export const DEFAULT_ECOPAGES_HOSTNAME = 'localhost';
+
 /**
  * Default directory used for deployable output.
  */
-export declare const DEFAULT_ECOPAGES_DIST_DIR = "dist";
+export const DEFAULT_ECOPAGES_DIST_DIR = 'dist';
+
 /**
  * Default internal working directory used for runtime-only artifacts.
  *
@@ -42,4 +51,4 @@ export declare const DEFAULT_ECOPAGES_DIST_DIR = "dist";
  * It owns transpiled server modules, runtime manifests, and processor caches
  * so the export directory can remain a clean deployable tree.
  */
-export declare const DEFAULT_ECOPAGES_WORK_DIR = ".eco";
+export const DEFAULT_ECOPAGES_WORK_DIR = '.eco';

package/src/dev/sc-server.ts

@@ -0,0 +1,143 @@
+import { extname, join } from 'node:path';
+import { STATUS_MESSAGE } from '../config/constants.ts';
+import { fileSystem } from '@ecopages/file-system';
+import { ServerUtils } from '../utils/server-utils.module.ts';
+import type { Server } from 'bun';
+import type { EcoPagesAppConfig } from '../types/internal-types.ts';
+import { getRequiredBunRuntime } from '../utils/runtime.ts';
+
+type StaticContentServerOptions = {
+	port?: number;
+};
+
+/**
+ * Static content server for production builds.
+ * Serves pre-built static files from the dist directory with gzip compression support.
+ */
+export class StaticContentServer {
+	server: Server<unknown> | null = null;
+	private appConfig: EcoPagesAppConfig;
+	private options: StaticContentServerOptions = { port: 3000 };
+
+	constructor({ appConfig, options }: { appConfig: EcoPagesAppConfig; options?: StaticContentServerOptions }) {
+		this.appConfig = appConfig;
+		if (options) this.options = options;
+		this.startServer();
+	}
+
+	private shouldServeGzip(contentType: ReturnType<typeof ServerUtils.getContentType>) {
+		return ['text/javascript', 'text/css'].includes(contentType);
+	}
+
+	private isHtml(contentType: string) {
+		return contentType === 'text/html';
+	}
+
+	private async sendNotFoundPage() {
+		const error404TemplatePath = `${this.appConfig.absolutePaths.distDir}/404.html`;
+
+		try {
+			fileSystem.exists(error404TemplatePath);
+		} catch {
+			return new Response(STATUS_MESSAGE[404], {
+				status: 404,
+			});
+		}
+
+		const response = new Response(fileSystem.readFileAsBuffer(error404TemplatePath) as BodyInit, {
+			headers: { 'Content-Type': 'text/html' },
+		});
+
+		return response;
+	}
+
+	private async serveFromDir({ path, request }: { path: string; request: Request }): Promise<Response> {
+		const { absolutePaths } = this.appConfig;
+		const basePath = join(absolutePaths.distDir, path);
+		const contentType = ServerUtils.getContentType(extname(basePath));
+		const acceptsGzip = request.headers.get('Accept-Encoding')?.includes('gzip');
+
+		try {
+			if (acceptsGzip && this.shouldServeGzip(contentType)) {
+				const gzipPath = `${basePath}.gz`;
+				if (fileSystem.exists(gzipPath)) {
+					const file = fileSystem.readFileAsBuffer(gzipPath) as BodyInit;
+					return new Response(file, {
+						headers: {
+							'Content-Type': contentType,
+							'Content-Encoding': 'gzip',
+							Vary: 'Accept-Encoding',
+						},
+					});
+				}
+			}
+
+			if (path.includes('.') && fileSystem.exists(basePath)) {
+				const file = fileSystem.readFileAsBuffer(basePath) as BodyInit;
+				return new Response(file, {
+					headers: { 'Content-Type': contentType },
+				});
+			}
+
+			const htmlCandidates = [`${basePath}.html`, `${basePath}/index.html`];
+
+			for (const candidate of htmlCandidates) {
+				if (fileSystem.exists(candidate)) {
+					const file = fileSystem.readFileAsBuffer(candidate) as BodyInit;
+					return new Response(file, {
+						headers: {
+							'Content-Type': ServerUtils.getContentType(extname(candidate)),
+						},
+					});
+				}
+			}
+
+			return this.sendNotFoundPage();
+		} catch {
+			return this.sendNotFoundPage();
+		}
+	}
+
+	async fetch(request: Request) {
+		let reqPath = new URL(request.url).pathname;
+
+		if (reqPath === '/') reqPath = '/index.html';
+
+		const response = this.serveFromDir({
+			path: reqPath,
+			request,
+		});
+
+		if (response) return response;
+
+		return new Response(STATUS_MESSAGE[404], {
+			status: 404,
+		});
+	}
+
+	private startServer() {
+		this.server = getRequiredBunRuntime().serve({
+			fetch: this.fetch.bind(this),
+			port: this.options.port,
+		});
+	}
+
+	stop() {
+		if (this.server) {
+			this.server.stop(true);
+		}
+	}
+
+	static createServer({
+		appConfig,
+		options,
+	}: {
+		appConfig: EcoPagesAppConfig;
+		options?: StaticContentServerOptions;
+	}) {
+		return new StaticContentServer({
+			appConfig: appConfig,
+			options,
+		});
+	}
+}

package/src/eco/eco.browser.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'vitest';
+import type { Middleware } from '../types/public-types.ts';
+import { eco } from './eco.browser.ts';
+
+describe('browser eco facade', () => {
+	test('creates browser-safe page components without server runtime imports', () => {
+		const Layout = eco.layout({
+			render: ({ children }) => `<main>${children ?? ''}</main>`,
+		});
+
+		const staticPaths = async () => ({ paths: [{ params: { slug: 'intro' } }] });
+		const metadata = async () => ({ title: 'Docs', description: 'Docs page' });
+		const middleware: Middleware[] = [async (_ctx, next) => next()];
+
+		const Page = eco.page({
+			layout: Layout,
+			dependencies: {
+				components: [Layout],
+			},
+			cache: 'dynamic',
+			staticPaths,
+			metadata,
+			middleware,
+			render: () => '<article>Docs</article>',
+		});
+
+		expect(Page({})).toBe('<article>Docs</article>');
+		expect(Page.config?.layout).toBe(Layout);
+		expect(Page.config?.dependencies?.components).toEqual([Layout, Layout]);
+		expect(Page.staticPaths).toBe(staticPaths);
+		expect(Page.metadata).toBe(metadata);
+		expect(Page.middleware).toBe(middleware);
+	});
+
+	test('preserves the metadata helper contract', async () => {
+		const getMetadata = eco.metadata(async () => ({ title: 'Browser title', description: 'Browser desc' }));
+
+		await expect(getMetadata({} as never)).resolves.toEqual({
+			title: 'Browser title',
+			description: 'Browser desc',
+		});
+	});
+});

package/src/eco/eco.browser.ts

@@ -0,0 +1,118 @@
+import type {
+	EcoComponent,
+	EcoHtmlComponent,
+	EcoLayoutComponent,
+	EcoPagesElement,
+	EcoPageComponent,
+	GetMetadata,
+	GetStaticPaths,
+	GetStaticProps,
+	Middleware,
+	RequestPageContext,
+} from '../types/public-types.ts';
+import type { CacheStrategy } from '../services/cache/cache.types.ts';
+import type { ComponentOptions, Eco, HtmlOptions, LayoutOptions, PageOptionsBase, PagePropsFor } from './eco.types.ts';
+
+function createComponentFactory<P, E>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
+	const component = ((props: P) => options.render(props)) as EcoComponent<P, E>;
+
+	component.config = {
+		__eco: options.__eco,
+		integration: options.integration,
+		dependencies: options.dependencies,
+	};
+
+	return component;
+}
+
+function component<P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
+	return createComponentFactory(options);
+}
+
+function html<E = EcoPagesElement>(options: HtmlOptions<E>): EcoHtmlComponent<E> {
+	return createComponentFactory(options) as EcoHtmlComponent<E>;
+}
+
+function layout<E = EcoPagesElement>(options: LayoutOptions<E>): EcoLayoutComponent<E> {
+	return createComponentFactory(options) as EcoLayoutComponent<E>;
+}
+
+function page<T, E>(
+	options: PageOptionsBase<T, E> & { cache?: CacheStrategy; middleware?: Middleware[] },
+): EcoPageComponent<T> {
+	const {
+		layout: pageLayout,
+		dependencies,
+		render,
+		staticPaths,
+		staticProps,
+		metadata,
+		cache,
+		requires,
+		middleware,
+	} = options;
+
+	const pageComponent = createComponentFactory({
+		__eco: options.__eco,
+		integration: options.integration,
+		dependencies: pageLayout
+			? {
+					...dependencies,
+					components: [...(dependencies?.components ?? []), pageLayout],
+				}
+			: dependencies,
+		render,
+	} as ComponentOptions<PagePropsFor<T> & Partial<RequestPageContext>, E>) as EcoPageComponent<T>;
+
+	if (pageLayout && pageComponent.config) {
+		pageComponent.config.layout = pageLayout;
+	}
+
+	if (staticPaths) {
+		pageComponent.staticPaths = staticPaths;
+	}
+
+	if (staticProps) {
+		pageComponent.staticProps = staticProps;
+	}
+
+	if (metadata) {
+		pageComponent.metadata = metadata;
+	}
+
+	if (cache) {
+		pageComponent.cache = cache;
+	}
+
+	if (requires) {
+		pageComponent.requires = requires;
+	}
+
+	if (middleware) {
+		pageComponent.middleware = middleware;
+	}
+
+	return pageComponent;
+}
+
+function metadata<T = Record<string, unknown>>(fn: GetMetadata<T>): GetMetadata<T> {
+	return fn;
+}
+
+function staticPaths(fn: GetStaticPaths): GetStaticPaths {
+	return fn;
+}
+
+function staticProps<P>(fn: GetStaticProps<P>): GetStaticProps<P> {
+	return fn;
+}
+
+export const eco: Eco = {
+	component,
+	html,
+	layout,
+	page,
+	metadata,
+	staticPaths,
+	staticProps,
+};