@ecopages/core 0.2.0-alpha.1

package/src/create-app.ts

@@ -0,0 +1,87 @@
+import type { EcopagesAppOptions as BunOptions } from './adapters/bun/create-app.ts';
+import type { EcopagesAppOptions as NodeOptions } from './adapters/node/create-app.ts';
+import { AbstractApplicationAdapter } from './adapters/abstract/application-adapter.ts';
+import type { ApiHandler } from './public-types.ts';
+import { SharedApplicationAdapter } from './adapters/shared/application-adapter.ts';
+
+export type EcopagesAppOptions = BunOptions | NodeOptions;
+export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, any, Request>;
+
+async function createRuntimeApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp> {
+	const bun = (globalThis as { Bun?: unknown }).Bun;
+
+	if (bun) {
+		const { createApp: createBunApp } = await import('./adapters/bun/create-app.ts');
+		return (await createBunApp<WebSocketData>(options as BunOptions)) as unknown as UniversalEcopagesApp;
+	}
+
+	const { createNodeApp } = await import('./adapters/node/create-app.ts');
+	return (await createNodeApp(options as NodeOptions)) as unknown as UniversalEcopagesApp;
+}
+
+export async function createApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp> {
+	return createRuntimeApp<WebSocketData>(options);
+}
+
+export class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, unknown, Request> {
+	private readonly appOptions: EcopagesAppOptions;
+	private runtimeApp: UniversalEcopagesApp | null = null;
+	private runtimeAppPromise: Promise<UniversalEcopagesApp> | null = null;
+
+	constructor(options: EcopagesAppOptions) {
+		super(options);
+		this.appOptions = options;
+	}
+
+	private async getRuntimeApp(): Promise<UniversalEcopagesApp> {
+		if (this.runtimeApp) {
+			return this.runtimeApp;
+		}
+
+		if (!this.runtimeAppPromise) {
+			this.runtimeAppPromise = createRuntimeApp({
+				...this.appOptions,
+				clearOutput: false,
+			}).then((app) => {
+				for (const handler of this.apiHandlers) {
+					app.add(handler as ApiHandler<string, Request, any>);
+				}
+
+				for (const route of this.staticRoutes) {
+					app.static(route.path, route.loader);
+				}
+
+				if (this.errorHandler) {
+					app.onError(this.errorHandler);
+				}
+
+				this.runtimeApp = app;
+				return app;
+			});
+		}
+
+		return this.runtimeAppPromise;
+	}
+
+	protected async initializeServerAdapter(): Promise<UniversalEcopagesApp> {
+		return this.getRuntimeApp();
+	}
+
+	async start(): Promise<unknown> {
+		const runtimeApp = await this.getRuntimeApp();
+		return runtimeApp.start();
+	}
+
+	async fetch(request: Request): Promise<Response> {
+		const runtimeApp = await this.getRuntimeApp();
+		const candidate = runtimeApp as UniversalEcopagesApp & {
+			fetch?: (request: Request) => Promise<Response>;
+		};
+
+		if (!candidate.fetch) {
+			throw new Error('The selected runtime adapter does not expose fetch()');
+		}
+
+		return candidate.fetch(request);
+	}
+}

package/src/declarations.d.ts

@@ -0,0 +1,26 @@
+import type { EcoPagesAppConfig } from './internal-types';
+
+type HMRHandler = (url: string) => Promise<void>;
+
+type ReloadPageFunction = (options: { clearCache: boolean }) => Promise<void>;
+
+declare global {
+	var ecoConfig: EcoPagesAppConfig;
+
+	interface Window {
+		/** Registered HMR handlers for specific module paths */
+		__ecopages_hmr_handlers__?: Record<string, HMRHandler>;
+		/** Function to reload the current page, used for layout updates */
+		__ecopages_reload_current_page__?: ReloadPageFunction;
+		/** Page data registry - contains module path and props for current page */
+		__ECO_PAGE__?: {
+			module: string;
+			props: Record<string, unknown>;
+		};
+	}
+}
+
+declare module '*.css' {
+	const styles: string;
+	export default styles;
+}

package/src/define-api-handler.d.ts

@@ -0,0 +1,25 @@
+import type { ApiHandler, ApiHandlerContext, Middleware, RouteSchema, TypedGroupHandlerContext } from './public-types.js';
+type UniversalContext = ApiHandlerContext<Request, unknown>;
+type SchemaHandlerContext<TSchema extends RouteSchema | undefined, TContext extends UniversalContext> = TSchema extends RouteSchema ? TypedGroupHandlerContext<TSchema, TContext> : TContext;
+export declare function defineApiHandler<TPath extends string, TSchema extends RouteSchema | undefined = undefined, TContext extends UniversalContext = UniversalContext>(handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
+    handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
+    middleware?: Middleware<Request, unknown, TContext>[];
+    schema?: TSchema;
+}): ApiHandler<TPath, Request, unknown>;
+export interface GroupHandler<TPrefix extends string = string> {
+    prefix: TPrefix;
+    middleware?: readonly Middleware<Request, unknown, any>[];
+    routes: readonly ApiHandler<string, Request, unknown>[];
+}
+type GroupDefineHandler<TContext extends UniversalContext> = <const TPath extends string, TSchema extends RouteSchema | undefined = undefined>(handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
+    path: TPath;
+    handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
+    middleware?: Middleware<Request, unknown, TContext>[];
+    schema?: TSchema;
+}) => ApiHandler<TPath, Request, unknown>;
+export declare function defineGroupHandler<TPrefix extends string, TMiddleware extends readonly Middleware<Request, unknown, any>[] = [], TContext extends UniversalContext = TMiddleware extends readonly Middleware<Request, unknown, infer TGroupContext>[] ? TGroupContext : UniversalContext>(config: {
+    prefix: TPrefix;
+    middleware?: TMiddleware;
+    routes: (define: GroupDefineHandler<TContext>) => readonly ApiHandler<string, Request, unknown>[];
+}): GroupHandler<TPrefix>;
+export {};

package/src/define-api-handler.js

@@ -0,0 +1,15 @@
+function defineApiHandler(handler) {
+  return handler;
+}
+function defineGroupHandler(config) {
+  const define = ((handler) => handler);
+  return {
+    prefix: config.prefix,
+    middleware: config.middleware,
+    routes: config.routes(define)
+  };
+}
+export {
+  defineApiHandler,
+  defineGroupHandler
+};

package/src/define-api-handler.ts

@@ -0,0 +1,66 @@
+import type {
+	ApiHandler,
+	ApiHandlerContext,
+	Middleware,
+	RouteSchema,
+	TypedGroupHandlerContext,
+} from './public-types.ts';
+
+type UniversalContext = ApiHandlerContext<Request, unknown>;
+
+type SchemaHandlerContext<
+	TSchema extends RouteSchema | undefined,
+	TContext extends UniversalContext,
+> = TSchema extends RouteSchema ? TypedGroupHandlerContext<TSchema, TContext> : TContext;
+
+export function defineApiHandler<
+	TPath extends string,
+	TSchema extends RouteSchema | undefined = undefined,
+	TContext extends UniversalContext = UniversalContext,
+>(
+	handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
+		handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
+		middleware?: Middleware<Request, unknown, TContext>[];
+		schema?: TSchema;
+	},
+): ApiHandler<TPath, Request, unknown> {
+	return handler as ApiHandler<TPath, Request, unknown>;
+}
+
+export interface GroupHandler<TPrefix extends string = string> {
+	prefix: TPrefix;
+	middleware?: readonly Middleware<Request, unknown, any>[];
+	routes: readonly ApiHandler<string, Request, unknown>[];
+}
+
+type GroupDefineHandler<TContext extends UniversalContext> = <
+	const TPath extends string,
+	TSchema extends RouteSchema | undefined = undefined,
+>(
+	handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
+		path: TPath;
+		handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
+		middleware?: Middleware<Request, unknown, TContext>[];
+		schema?: TSchema;
+	},
+) => ApiHandler<TPath, Request, unknown>;
+
+export function defineGroupHandler<
+	TPrefix extends string,
+	TMiddleware extends readonly Middleware<Request, unknown, any>[] = [],
+	TContext extends UniversalContext = TMiddleware extends readonly Middleware<Request, unknown, infer TGroupContext>[]
+		? TGroupContext
+		: UniversalContext,
+>(config: {
+	prefix: TPrefix;
+	middleware?: TMiddleware;
+	routes: (define: GroupDefineHandler<TContext>) => readonly ApiHandler<string, Request, unknown>[];
+}): GroupHandler<TPrefix> {
+	const define = ((handler) => handler) as GroupDefineHandler<TContext>;
+
+	return {
+		prefix: config.prefix,
+		middleware: config.middleware,
+		routes: config.routes(define),
+	};
+}

package/src/dev/sc-server.d.ts

@@ -0,0 +1,30 @@
+import type { Server } from 'bun';
+import type { EcoPagesAppConfig } from '../internal-types.js';
+type StaticContentServerOptions = {
+    port?: number;
+};
+/**
+ * Static content server for production builds.
+ * Serves pre-built static files from the dist directory with gzip compression support.
+ */
+export declare class StaticContentServer {
+    server: Server<unknown> | null;
+    private appConfig;
+    private options;
+    constructor({ appConfig, options }: {
+        appConfig: EcoPagesAppConfig;
+        options?: StaticContentServerOptions;
+    });
+    private shouldServeGzip;
+    private isHtml;
+    private sendNotFoundPage;
+    private serveFromDir;
+    fetch(request: Request): Promise<Response>;
+    private startServer;
+    stop(): void;
+    static createServer({ appConfig, options, }: {
+        appConfig: EcoPagesAppConfig;
+        options?: StaticContentServerOptions;
+    }): StaticContentServer;
+}
+export {};

package/src/dev/sc-server.js

@@ -0,0 +1,111 @@
+import { extname, join } from "node:path";
+import { STATUS_MESSAGE } from "../constants.js";
+import { fileSystem } from "@ecopages/file-system";
+import { ServerUtils } from "../utils/server-utils.module.js";
+import { getRequiredBunRuntime } from "../utils/runtime.js";
+class StaticContentServer {
+  server = null;
+  appConfig;
+  options = { port: 3e3 };
+  constructor({ appConfig, options }) {
+    this.appConfig = appConfig;
+    if (options) this.options = options;
+    this.startServer();
+  }
+  shouldServeGzip(contentType) {
+    return ["text/javascript", "text/css"].includes(contentType);
+  }
+  isHtml(contentType) {
+    return contentType === "text/html";
+  }
+  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), {
+      headers: { "Content-Type": "text/html" }
+    });
+    return response;
+  }
+  async serveFromDir({ path, request }) {
+    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);
+          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);
+        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);
+          return new Response(file, {
+            headers: {
+              "Content-Type": ServerUtils.getContentType(extname(candidate))
+            }
+          });
+        }
+      }
+      return this.sendNotFoundPage();
+    } catch {
+      return this.sendNotFoundPage();
+    }
+  }
+  async fetch(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
+    });
+  }
+  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
+  }) {
+    return new StaticContentServer({
+      appConfig,
+      options
+    });
+  }
+}
+export {
+  StaticContentServer
+};

package/src/dev/sc-server.ts

@@ -0,0 +1,143 @@
+import { extname, join } from 'node:path';
+import { STATUS_MESSAGE } from '../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 '../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,
+		});
+	}
+}