@ecopages/core 0.2.0-beta.8 → 0.2.0-rc.0

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
  */
@@ -32,8 +33,18 @@ export interface ServerAdapterResult {
     buildStatic: (options?: {
         preview?: boolean;
         force?: boolean;
-    }) => Promise<void>;
+    }) => 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
@@ -60,7 +71,7 @@ export declare abstract class AbstractServerAdapter<TOptions extends ServerAdapt
     abstract buildStatic(options?: {
         preview?: boolean;
         force?: boolean;
-    }): Promise<void>;
+    }): 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

@@ -1,60 +1,12 @@
 import type { EcopagesWebSocketHandler } from '../../types/public-types.js';
-/**
- * Pattern matcher for WebSocket route paths.
- *
- * Supports dynamic segments via `:param` syntax. Matches are exact on literal
- * segments and capture dynamic segments into a params object.
- *
- * @example
- * ```ts
- * matchWebSocketPath('/ws/chat/:id', '/ws/chat/abc123')
- * // Returns: { id: 'abc123' }
- *
- * matchWebSocketPath('/ws/chat/:id', '/ws/chat/abc123/messages')
- * // Returns: null (length mismatch)
- *
- * matchWebSocketPath('/ws/chat', '/ws/chat')
- * // Returns: {} (no params)
- * ```
- *
- * @remarks
- * This is a minimal segment-based matcher. It does not support wildcards,
- * optional segments, or catch-all patterns. Those are future concerns.
- *
- * @param pattern - The registered route pattern (e.g. '/ws/chat/:id')
- * @param pathname - The actual request pathname (e.g. '/ws/chat/abc123')
- * @returns A params object if the pattern matches, or null if it does not
- */
-export declare function matchWebSocketPath(pattern: string, pathname: string): Record<string, string> | null;
-/**
- * Represents a matched WebSocket route.
- */
 export type WebSocketRouteMatch = {
     handler: EcopagesWebSocketHandler<any, any>;
     params: Record<string, string>;
     kind: string;
 };
 /**
- * Scores a pattern for specificity ordering.
- *
- * Higher scores win. Rules, in order:
- * 1. More literal segments beats more dynamic segments.
- * 2. Fewer dynamic segments beats more dynamic segments.
- * 3. Longer route (more segments) beats shorter route.
- *
- * @param pattern - The registered route pattern
- * @returns A numeric specificity score
+ * 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;
-/**
- * Find the registered WebSocket handler that best matches a pathname.
- *
- * Iterates through the provided handlers map, computes each pattern's
- * specificity score, and returns the highest-scoring match. Ties resolve
- * to the earliest-registered pattern.
- *
- * @param handlers - The map of registered WebSocket handlers
- * @param pathname - The actual request pathname
- * @returns The best match, or null if no pattern matches
- */
 export declare function findWebSocketRoute(handlers: Map<string, EcopagesWebSocketHandler<any, any>>, pathname: string): WebSocketRouteMatch | null;

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

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

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.js

@@ -1,51 +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;
-  }
-  destroy() {
-    this.subscribers.clear();
-  }
+/**
+ * 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';
 /**
@@ -33,10 +32,8 @@ export declare class BunEcopagesApp<WebSocketData = undefined> extends SharedApp
     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?: {
@@ -56,8 +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