@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.40

package/src/adapters/abstract/segment-path-matcher.js

@@ -0,0 +1,147 @@
+export function normalizeSegmentPath(pathname) {
+    if (pathname.length > 1 && pathname.endsWith('/')) {
+        return pathname.slice(0, -1);
+    }
+    return pathname;
+}
+export function matchApiPathPattern(pattern, pathname) {
+    const normalizedPattern = normalizeSegmentPath(pattern);
+    const normalizedPathname = normalizeSegmentPath(pathname);
+    const patternSegments = normalizedPattern.split('/').filter(Boolean);
+    const pathSegments = normalizedPathname.split('/').filter(Boolean);
+    const params = {};
+    let patternIndex = 0;
+    let pathIndex = 0;
+    while (patternIndex < patternSegments.length && pathIndex < pathSegments.length) {
+        const patternSegment = patternSegments[patternIndex];
+        const pathSegment = pathSegments[pathIndex];
+        if (patternSegment === '*') {
+            return params;
+        }
+        if (patternSegment.startsWith('[...') && patternSegment.endsWith(']')) {
+            const paramName = patternSegment.slice(4, -1);
+            params[paramName] = pathSegments.slice(pathIndex);
+            return params;
+        }
+        if (patternSegment.startsWith(':')) {
+            params[patternSegment.slice(1)] = pathSegment;
+            patternIndex++;
+            pathIndex++;
+            continue;
+        }
+        if (patternSegment.startsWith('[') && patternSegment.endsWith(']')) {
+            params[patternSegment.slice(1, -1)] = pathSegment;
+            patternIndex++;
+            pathIndex++;
+            continue;
+        }
+        if (patternSegment !== pathSegment) {
+            return null;
+        }
+        patternIndex++;
+        pathIndex++;
+    }
+    if (patternIndex < patternSegments.length) {
+        const remaining = patternSegments.slice(patternIndex);
+        const catchAll = remaining[0];
+        if (remaining.length === 1 && (catchAll === '*' || (catchAll.startsWith('[...') && catchAll.endsWith(']')))) {
+            if (catchAll.startsWith('[...')) {
+                const paramName = catchAll.slice(4, -1);
+                params[paramName] = [];
+            }
+            return params;
+        }
+        return null;
+    }
+    if (pathIndex < pathSegments.length) {
+        return null;
+    }
+    return params;
+}
+export function scoreApiPathPattern(pattern) {
+    const segments = normalizeSegmentPath(pattern).split('/').filter(Boolean);
+    let score = 0;
+    for (const segment of segments) {
+        if (segment === '*' || (segment.startsWith('[...') && segment.endsWith(']'))) {
+            score += 10;
+        }
+        else if (segment.startsWith(':') || (segment.startsWith('[') && segment.endsWith(']'))) {
+            score += 50;
+        }
+        else {
+            score += 100;
+        }
+    }
+    return score;
+}
+export function matchExplicitStaticPathPattern(pattern, pathname) {
+    const patternSegments = normalizeSegmentPath(pattern).split('/').filter(Boolean);
+    const pathSegments = normalizeSegmentPath(pathname).split('/').filter(Boolean);
+    if (patternSegments.length !== pathSegments.length) {
+        const lastPattern = patternSegments[patternSegments.length - 1];
+        const isCatchAll = lastPattern?.startsWith('[...') || lastPattern?.startsWith(':...');
+        if (!isCatchAll) {
+            return null;
+        }
+    }
+    const params = {};
+    for (let i = 0; i < patternSegments.length; i++) {
+        const patternPart = patternSegments[i];
+        const pathPart = pathSegments[i];
+        if (patternPart.startsWith(':...') || patternPart.startsWith('[...')) {
+            const paramName = patternPart.replace(/^(:\.\.\.|\[\.\.\.)/, '').replace(/\]$/, '');
+            params[paramName] = pathSegments.slice(i).join('/');
+            return params;
+        }
+        if (patternPart.startsWith(':')) {
+            params[patternPart.slice(1)] = pathPart;
+        }
+        else if (patternPart.startsWith('[') && patternPart.endsWith(']')) {
+            params[patternPart.slice(1, -1)] = pathPart;
+        }
+        else if (patternPart !== pathPart) {
+            return null;
+        }
+    }
+    return params;
+}
+export function matchColonSegmentPath(pattern, pathname) {
+    const patternSegments = pattern.split('/').filter(Boolean);
+    const pathSegments = pathname.split('/').filter(Boolean);
+    if (patternSegments.length !== pathSegments.length) {
+        return null;
+    }
+    const params = {};
+    for (let i = 0; i < patternSegments.length; i++) {
+        const patternSegment = patternSegments[i];
+        const pathSegment = pathSegments[i];
+        if (!patternSegment || !pathSegment) {
+            return null;
+        }
+        if (patternSegment.startsWith(':')) {
+            const paramName = patternSegment.slice(1);
+            if (!paramName) {
+                return null;
+            }
+            params[paramName] = pathSegment;
+        }
+        else if (patternSegment !== pathSegment) {
+            return null;
+        }
+    }
+    return params;
+}
+export function scoreColonSegmentPath(pattern) {
+    const segments = pattern.split('/').filter(Boolean);
+    let literals = 0;
+    let dynamics = 0;
+    for (const segment of segments) {
+        if (segment.startsWith(':')) {
+            dynamics += 1;
+        }
+        else {
+            literals += 1;
+        }
+    }
+    return literals * 100 - dynamics * 10 + segments.length;
+}

package/src/adapters/abstract/server-adapter.d.ts

@@ -8,6 +8,7 @@
  */
 import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 import type { ApiHandler } from '../../types/public-types.js';
+import type { StaticGenerationRoute } from '../../router/server/route-registry.js';
 /**
  * Configuration options for all server adapters
  */
@@ -31,7 +32,19 @@ export interface ServerAdapterResult {
     }) => any;
     buildStatic: (options?: {
         preview?: boolean;
-    }) => Promise<void>;
+        force?: boolean;
+    }) => Promise<string | undefined>;
+    servePreviewOnly: () => Promise<string | undefined>;
+    dispose(): Promise<void>;
+    /**
+     * Lists static-generation routes for app-start consumers.
+     *
+     * @remarks
+     * Optional so lightweight adapter stubs in tests need not implement routing.
+     */
+    listStaticGenerationRoutes?: (input: {
+        runtimeOrigin: string;
+    }) => Promise<readonly StaticGenerationRoute[]>;
 }
 /**
  * Abstract base class for server adapters across different runtimes
@@ -57,7 +70,8 @@ export declare abstract class AbstractServerAdapter<TOptions extends ServerAdapt
      */
     abstract buildStatic(options?: {
         preview?: boolean;
-    }): Promise<void>;
+        force?: boolean;
+    }): Promise<string | undefined>;
     /**
      * Factory method to create a server adapter with runtime-specific functionality
      */

package/src/adapters/abstract/server-adapter.js

@@ -1,15 +1,23 @@
-class AbstractServerAdapter {
-  appConfig;
-  options;
-  serveOptions;
-  runtimeOrigin;
-  constructor(options) {
-    this.appConfig = options.appConfig;
-    this.options = options.options || {};
-    this.serveOptions = options.serveOptions || {};
-    this.runtimeOrigin = options.runtimeOrigin;
-  }
+/**
+ * This file contains the abstract server adapter class and its related types.
+ * It is designed to be extended by specific server adapters for different runtimes.
+ * The class provides methods for initializing the server, creating server options,
+ * building static files, and handling HTTP requests.
+ *
+ * @module ServerAdapter
+ */
+/**
+ * Abstract base class for server adapters across different runtimes
+ */
+export class AbstractServerAdapter {
+    appConfig;
+    options;
+    serveOptions;
+    runtimeOrigin;
+    constructor(options) {
+        this.appConfig = options.appConfig;
+        this.options = options.options || {};
+        this.serveOptions = options.serveOptions || {};
+        this.runtimeOrigin = options.runtimeOrigin;
+    }
 }
-export {
-  AbstractServerAdapter
-};

package/src/adapters/abstract/ws-pattern-matcher.d.ts

@@ -0,0 +1,12 @@
+import type { EcopagesWebSocketHandler } from '../../types/public-types.js';
+export type WebSocketRouteMatch = {
+    handler: EcopagesWebSocketHandler<any, any>;
+    params: Record<string, string>;
+    kind: string;
+};
+/**
+ * Pattern matcher for WebSocket route paths.
+ */
+export declare function matchWebSocketPath(pattern: string, pathname: string): Record<string, string> | null;
+export declare function scoreWebSocketPattern(pattern: string): number;
+export declare function findWebSocketRoute(handlers: Map<string, EcopagesWebSocketHandler<any, any>>, pathname: string): WebSocketRouteMatch | null;

package/src/adapters/abstract/ws-pattern-matcher.js

@@ -0,0 +1,28 @@
+import { matchColonSegmentPath, scoreColonSegmentPath } from './segment-path-matcher.js';
+/**
+ * Pattern matcher for WebSocket route paths.
+ */
+export function matchWebSocketPath(pattern, pathname) {
+    return matchColonSegmentPath(pattern, pathname);
+}
+export function scoreWebSocketPattern(pattern) {
+    return scoreColonSegmentPath(pattern);
+}
+export function findWebSocketRoute(handlers, pathname) {
+    let best = null;
+    let index = 0;
+    for (const [pattern, handler] of handlers) {
+        const params = matchColonSegmentPath(pattern, pathname);
+        if (params === null) {
+            index += 1;
+            continue;
+        }
+        const score = scoreColonSegmentPath(pattern);
+        const match = { handler, params, kind: pattern };
+        if (best === null || score > best.score || (score === best.score && index < best.index)) {
+            best = { score, match, index };
+        }
+        index += 1;
+    }
+    return best?.match ?? null;
+}

package/src/adapters/bun/bun-user-websocket-lifecycle.d.ts

@@ -0,0 +1,22 @@
+import type { ServerWebSocket } from 'bun';
+import type { EcopagesSocket, EcopagesWebSocketHandler } from '../../types/public-types.js';
+export type BunUserWebSocketData = {
+    kind: string;
+    params: Record<string, string>;
+    search: Record<string, string>;
+    upgradeUrl?: string;
+    context?: unknown;
+    [key: string]: unknown;
+};
+export type BunUserWebSocketLifecycleDeps<TWsData extends BunUserWebSocketData> = {
+    runtimeOrigin: string;
+    userHandlers: Map<string, EcopagesWebSocketHandler<any, any>>;
+    resolveContext: <TContext, TParams extends Record<string, string>>(request: Request, handler: EcopagesWebSocketHandler<TContext, TParams>, kind: string, params: TParams, search: Record<string, string>) => Promise<TContext>;
+    adaptSocket: <TContext, TParams extends Record<string, string>>(ws: ServerWebSocket<TWsData>, kind: string, params: TParams, search: Record<string, string>, context: TContext) => EcopagesSocket<TContext, TParams>;
+};
+export declare function createBunUserWebSocketLifecycle<TWsData extends BunUserWebSocketData>(deps: BunUserWebSocketLifecycleDeps<TWsData>): {
+    open(ws: ServerWebSocket<TWsData>): void;
+    message(ws: ServerWebSocket<TWsData>, msg: string | Buffer): void;
+    close(ws: ServerWebSocket<TWsData>, code: number, reason: string): void;
+    error(ws: ServerWebSocket<TWsData>, error: Error): void;
+};

package/src/adapters/bun/bun-user-websocket-lifecycle.js

@@ -0,0 +1,93 @@
+import { appLogger } from '../../global/app-logger.js';
+import { invokeWebSocketHandlerHook, toWebSocketCloseInfo } from '../shared/ws/websocket-lifecycle.js';
+function toUpgradeRequest(ws, runtimeOrigin) {
+    const upgradeUrl = ws.data?.upgradeUrl;
+    if (upgradeUrl) {
+        return new Request(upgradeUrl);
+    }
+    return new Request(runtimeOrigin);
+}
+async function runUserWebSocketOpen(ws, kind, deps) {
+    const handler = deps.userHandlers.get(kind);
+    if (!handler) {
+        return;
+    }
+    const params = (ws.data?.params ?? {});
+    const search = ws.data?.search ?? {};
+    const request = toUpgradeRequest(ws, deps.runtimeOrigin);
+    let context;
+    try {
+        context = await deps.resolveContext(request, handler, kind, params, search);
+    }
+    catch {
+        ws.close(1011, 'context initialization failed');
+        return;
+    }
+    ws.data.context = context;
+    const socket = deps.adaptSocket(ws, kind, params, search, context);
+    try {
+        await handler.onConnect?.(socket);
+    }
+    catch (error) {
+        appLogger.error(`[WS:${kind}] onConnect failed:`, error);
+        ws.close(1011, 'onConnect failed');
+    }
+}
+export function createBunUserWebSocketLifecycle(deps) {
+    const resolveSocketForEvent = (ws) => {
+        const kind = ws.data?.kind;
+        if (!kind) {
+            return undefined;
+        }
+        const handler = deps.userHandlers.get(kind);
+        if (!handler) {
+            return undefined;
+        }
+        const params = (ws.data?.params ?? {});
+        const search = ws.data?.search ?? {};
+        const socket = deps.adaptSocket(ws, kind, params, search, ws.data?.context);
+        return { kind, handler, socket };
+    };
+    return {
+        open(ws) {
+            const kind = ws.data?.kind;
+            if (!kind) {
+                return;
+            }
+            void runUserWebSocketOpen(ws, kind, deps).catch((error) => {
+                appLogger.error(`[WS:${kind}] open failed:`, error);
+                ws.close(1011, 'internal error');
+            });
+        },
+        message(ws, msg) {
+            const resolved = resolveSocketForEvent(ws);
+            if (!resolved) {
+                return;
+            }
+            if (ws.data?.context === undefined && resolved.handler.context) {
+                appLogger.warn(`[WS:${resolved.kind}] message received before context resolved; dropping.`);
+                return;
+            }
+            const message = typeof msg === 'string'
+                ? { kind: 'text', text: msg }
+                : { kind: 'binary', data: new Uint8Array(msg.buffer, msg.byteOffset, msg.byteLength) };
+            invokeWebSocketHandlerHook(resolved.kind, 'onMessage', resolved.handler.onMessage?.(resolved.socket, message));
+        },
+        close(ws, code, reason) {
+            const resolved = resolveSocketForEvent(ws);
+            if (!resolved) {
+                return;
+            }
+            const event = toWebSocketCloseInfo(code, reason);
+            invokeWebSocketHandlerHook(resolved.kind, 'onClose', resolved.handler.onClose?.(resolved.socket, event));
+        },
+        error(ws, error) {
+            const resolved = resolveSocketForEvent(ws);
+            if (!resolved) {
+                return;
+            }
+            appLogger.error(`[WS:${resolved.kind}] error:`, error);
+            invokeWebSocketHandlerHook(resolved.kind, 'onError', resolved.handler.onError?.(resolved.socket, error));
+        },
+    };
+}

package/src/adapters/bun/client-bridge.d.ts

@@ -30,5 +30,6 @@ export declare class ClientBridge implements IClientBridge {
      */
     error(message: string): void;
     get subscriberCount(): number;
+    destroy(): void;
 }
 export {};

package/src/adapters/bun/client-bridge.js

@@ -1,48 +1,52 @@
-class ClientBridge {
-  subscribers = /* @__PURE__ */ new Set();
-  subscribe(ws) {
-    this.subscribers.add(ws);
-  }
-  unsubscribe(ws) {
-    this.subscribers.delete(ws);
-  }
-  /**
-   * Broadcast a raw event to all connected clients.
-   */
-  broadcast(event) {
-    const payload = JSON.stringify(event);
-    for (const ws of this.subscribers) {
-      ws.send(payload);
-    }
-  }
-  /**
-   * Trigger a full page reload on all connected clients.
-   */
-  reload() {
-    this.broadcast({ type: "reload" });
-  }
-  /**
-   * Broadcast a CSS update for hot stylesheet reload.
-   */
-  cssUpdate(path) {
-    this.broadcast({ type: "css-update", path, timestamp: Date.now() });
-  }
-  /**
-   * Broadcast a JS module update for hot module replacement.
-   */
-  update(path) {
-    this.broadcast({ type: "update", path, timestamp: Date.now() });
-  }
-  /**
-   * Broadcast an error message to connected clients.
-   */
-  error(message) {
-    this.broadcast({ type: "error", message });
-  }
-  get subscriberCount() {
-    return this.subscribers.size;
-  }
+/**
+ * Manages WebSocket subscribers and broadcasts development events.
+ * Bridges the gap between the server and the development client.
+ */
+export class ClientBridge {
+    subscribers = new Set();
+    subscribe(ws) {
+        this.subscribers.add(ws);
+    }
+    unsubscribe(ws) {
+        this.subscribers.delete(ws);
+    }
+    /**
+     * Broadcast a raw event to all connected clients.
+     */
+    broadcast(event) {
+        const payload = JSON.stringify(event);
+        for (const ws of this.subscribers) {
+            ws.send(payload);
+        }
+    }
+    /**
+     * Trigger a full page reload on all connected clients.
+     */
+    reload() {
+        this.broadcast({ type: 'reload' });
+    }
+    /**
+     * Broadcast a CSS update for hot stylesheet reload.
+     */
+    cssUpdate(path) {
+        this.broadcast({ type: 'css-update', path, timestamp: Date.now() });
+    }
+    /**
+     * Broadcast a JS module update for hot module replacement.
+     */
+    update(path) {
+        this.broadcast({ type: 'update', path, timestamp: Date.now() });
+    }
+    /**
+     * Broadcast an error message to connected clients.
+     */
+    error(message) {
+        this.broadcast({ type: 'error', message });
+    }
+    get subscriberCount() {
+        return this.subscribers.size;
+    }
+    destroy() {
+        this.subscribers.clear();
+    }
 }
-export {
-  ClientBridge
-};

package/src/adapters/bun/create-app.d.ts

@@ -9,9 +9,8 @@
  */
 import type { Server } from 'bun';
 import type { ApiHandlerContext, RouteGroupBuilder } from '../../types/public-types.js';
-import { SharedApplicationAdapter } from '../shared/application-adapter.js';
-import type { RuntimeHost } from '../shared/runtime-host.js';
-import type { StaticPreviewHost } from '../shared/static-preview-host.js';
+import { SharedApplicationAdapter } from '../shared/runtime/application-adapter.js';
+import type { RuntimeHost } from '../shared/runtime/runtime-host.js';
 import type { EcopagesAppOptions } from '../create-app.js';
 import { type BunServerAdapterResult } from './server-adapter.js';
 /**
@@ -31,13 +30,15 @@ export type BunRouteGroupBuilder<WebSocketData = undefined, TContext extends Api
 export declare class BunEcopagesApp<WebSocketData = undefined> extends SharedApplicationAdapter<EcopagesAppOptions, Server<WebSocketData>, Request> {
     serverAdapter: BunServerAdapterResult | undefined;
     private server;
+    private stopped;
     private readonly runtimeHost;
-    private readonly previewHost;
     constructor(options: EcopagesAppOptions, dependencies: {
         runtimeHost: RuntimeHost<Server<WebSocketData>, Bun.Serve.Options<WebSocketData>>;
-        previewHost: StaticPreviewHost;
     });
     fetch(request: Request): Promise<Response>;
+    attachWebSocketUpgrades(httpServer: import('node:http').Server, options?: {
+        passthroughUnmatched?: boolean;
+    }): Promise<void>;
     /**
      * Complete the initialization of the server adapter by processing dynamic routes
      * @param server The Bun server instance
@@ -52,7 +53,9 @@ export declare class BunEcopagesApp<WebSocketData = undefined> extends SharedApp
      * @param options Optional settings
      * @param options.autoCompleteInitialization Whether to automatically complete initialization with dynamic routes after server start (defaults to true)
      */
-    start(): Promise<Server<WebSocketData> | void>;
+    protected bootServer(): Promise<Server<WebSocketData> | void>;
+    stop(force?: boolean): Promise<void>;
+    protected resolveAppRoutes(): Promise<import("../../index.browser.js").EcopagesRouteInfo[]>;
 }
 /**
  * Factory function to create a Bun application