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

package/src/adapters/bun/static-preview-host.d.ts

@@ -1,5 +1,5 @@
 import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { StaticPreviewHost, StaticPreviewHostStartOptions } from '../shared/static-preview-host.js';
+import type { StaticPreviewHost, StaticPreviewHostStartOptions } from '../shared/runtime/static-preview-host.js';
 type BunStaticPreviewServer = {
     server: {
         port?: number;

package/src/adapters/bun/static-preview-host.js

@@ -1,45 +1,47 @@
-import { StaticContentServer } from "../../dev/sc-server.js";
-import { appLogger } from "../../global/app-logger.js";
-class BunStaticPreviewHost {
-  constructor(previewServerFactory = StaticContentServer, logger = appLogger) {
-    this.previewServerFactory = previewServerFactory;
-    this.logger = logger;
-  }
-  previewServerFactory;
-  logger;
-  previewServer = null;
-  async start(options) {
-    await this.stop();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    for (let attempt = 0; attempt < 20; attempt += 1) {
-      try {
-        this.previewServer = this.previewServerFactory.createServer({
-          appConfig: options.appConfig,
-          options: { port: options.port }
+import { StaticContentServer } from '../../dev/sc-server.js';
+import { appLogger } from '../../global/app-logger.js';
+import { PortManager } from '../shared/runtime/port-manager.js';
+export class BunStaticPreviewHost {
+    previewServerFactory;
+    logger;
+    previewServer = null;
+    constructor(previewServerFactory = StaticContentServer, logger = appLogger) {
+        this.previewServerFactory = previewServerFactory;
+        this.logger = logger;
+    }
+    async start(options) {
+        await this.stop();
+        let previewServer = null;
+        const portManager = new PortManager({
+            startOnPort: async (port) => {
+                const candidate = this.previewServerFactory.createServer({
+                    appConfig: options.appConfig,
+                    options: { port },
+                });
+                const boundPort = candidate.server?.port ?? null;
+                if (!boundPort) {
+                    candidate.stop();
+                    return null;
+                }
+                previewServer = candidate;
+                return boundPort;
+            },
+            warn: (message) => appLogger.warn(message),
         });
-        const previewPort = this.previewServer.server?.port;
-        if (previewPort) {
-          return previewPort;
-        }
-        break;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorCode = typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
-        const isPortReleaseRace = errorCode === "EADDRINUSE" || errorMessage.includes("EADDRINUSE");
-        if (!isPortReleaseRace || attempt === 19) {
-          throw error;
+        const previewPort = await portManager.bind({
+            preferredPort: options.port,
+            allowPortFallback: options.allowPortFallback === true,
+        });
+        if (!previewPort) {
+            this.previewServer = null;
+            this.logger.error('Failed to start preview server');
+            return null;
         }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
+        this.previewServer = previewServer;
+        return previewPort;
+    }
+    async stop() {
+        this.previewServer?.stop();
+        this.previewServer = null;
     }
-    this.logger.error("Failed to start preview server");
-    return null;
-  }
-  async stop() {
-    this.previewServer?.stop();
-    this.previewServer = null;
-  }
 }
-export {
-  BunStaticPreviewHost
-};

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

@@ -1,7 +1,7 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
 import { AbstractApplicationAdapter } from './abstract/application-adapter.js';
 import type { ApplicationAdapterOptions } from './abstract/application-adapter.js';
-import { SharedApplicationAdapter } from './shared/application-adapter.js';
+export type { OnAppStartCallback, AppStartInfo, StartCallback, ListenCallback, ApplicationListeningCallback, ApplicationListeningInfo, } from './abstract/application-adapter.js';
 export type EcopagesRuntimeAdapter = 'auto' | 'node' | 'bun';
 export interface EcopagesAppOptions extends ApplicationAdapterOptions {
     appConfig: EcoPagesAppConfig;
@@ -20,14 +20,3 @@ export interface EcopagesAppOptions extends ApplicationAdapterOptions {
 }
 export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, unknown, Request>;
 export declare function createApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp>;
-export declare class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, unknown, Request> {
-    private readonly appOptions;
-    private runtimeApp;
-    private runtimeAppPromise;
-    constructor(options: EcopagesAppOptions);
-    private getRuntimeApp;
-    protected initializeServerAdapter(): Promise<UniversalEcopagesApp>;
-    start(): Promise<unknown>;
-    fetch(request: Request): Promise<Response>;
-    stop(force?: boolean): Promise<void>;
-}

package/src/adapters/create-app.js

@@ -1,75 +1,14 @@
-import { AbstractApplicationAdapter } from "./abstract/application-adapter.js";
-import { SharedApplicationAdapter } from "./shared/application-adapter.js";
-import { createApp as createBunApp } from "./bun/create-app.js";
-import { createNodeApp } from "./node/create-app.js";
+import { AbstractApplicationAdapter } from './abstract/application-adapter.js';
+import { createApp as createBunApp } from './bun/create-app.js';
+import { createNodeApp } from './node/create-app.js';
 async function createRuntimeApp(options) {
-  const adapter = options.adapter ?? "auto";
-  const bun = globalThis.Bun;
-  if (adapter === "bun" || adapter === "auto" && bun) {
-    return await createBunApp(options);
-  }
-  return await createNodeApp(options);
-}
-async function createApp(options) {
-  return createRuntimeApp(options);
-}
-class EcopagesApp extends SharedApplicationAdapter {
-  appOptions;
-  runtimeApp = null;
-  runtimeAppPromise = null;
-  constructor(options) {
-    super(options);
-    this.appOptions = options;
-  }
-  async getRuntimeApp() {
-    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);
-        }
-        for (const route of this.staticRoutes) {
-          app.static(route.path, route.loader);
-        }
-        if (this.errorHandler) {
-          app.onError(this.errorHandler);
-        }
-        this.runtimeApp = app;
-        return app;
-      });
+    const adapter = options.adapter ?? 'auto';
+    const bun = globalThis.Bun;
+    if (adapter === 'bun' || (adapter === 'auto' && bun)) {
+        return (await createBunApp(options));
     }
-    return this.runtimeAppPromise;
-  }
-  async initializeServerAdapter() {
-    return this.getRuntimeApp();
-  }
-  async start() {
-    const runtimeApp = await this.getRuntimeApp();
-    return runtimeApp.start();
-  }
-  async fetch(request) {
-    const runtimeApp = await this.getRuntimeApp();
-    const candidate = runtimeApp;
-    if (!candidate.fetch) {
-      throw new Error("The selected runtime adapter does not expose fetch()");
-    }
-    return candidate.fetch(request);
-  }
-  async stop(force = true) {
-    const runtimeApp = this.runtimeApp ?? (this.runtimeAppPromise ? await this.runtimeAppPromise : null);
-    if (runtimeApp) {
-      await runtimeApp.stop(force);
-    }
-    this.runtimeApp = null;
-    this.runtimeAppPromise = null;
-  }
+    return (await createNodeApp(options));
+}
+export async function createApp(options) {
+    return createRuntimeApp(options);
 }
-export {
-  EcopagesApp,
-  createApp
-};

package/src/adapters/index.d.ts

@@ -1,2 +1,2 @@
-export { EcopagesApp, createApp } from './create-app.js';
-export { defineApiHandler, defineGroupHandler, type GroupHandler } from './shared/define-api-handler.js';
+export { createApp } from './create-app.js';
+export { defineApiHandler, defineGroupHandler, defineGet, definePost, definePut, defineDelete, definePatch, defineOptions, defineHead, json, html, redirect, type GroupHandler, } from './shared/http/define-api-handler.js';

package/src/adapters/index.js

@@ -1,8 +1,2 @@
-import { EcopagesApp, createApp } from "./create-app.js";
-import { defineApiHandler, defineGroupHandler } from "./shared/define-api-handler.js";
-export {
-  EcopagesApp,
-  createApp,
-  defineApiHandler,
-  defineGroupHandler
-};
+export { createApp } from './create-app.js';
+export { defineApiHandler, defineGroupHandler, defineGet, definePost, definePut, defineDelete, definePatch, defineOptions, defineHead, json, html, redirect, } from './shared/http/define-api-handler.js';

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

@@ -1,5 +1,5 @@
-import { SharedApplicationAdapter } from '../shared/application-adapter.js';
-import type { RuntimeHost } from '../shared/runtime-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 NodeServerAdapterResult, createNodeServerAdapter } from './server-adapter.js';
 import type { NodeServerInstance } from './server-adapter.js';
@@ -17,8 +17,9 @@ export declare class NodeEcopagesApp extends SharedApplicationAdapter<EcopagesAp
     });
     protected createServerAdapter(params: Parameters<typeof createNodeServerAdapter>[0]): Promise<NodeServerAdapterResult>;
     stop(force?: boolean): Promise<void>;
+    protected resolveAppRoutes(): Promise<import("../../index.browser.js").EcopagesRouteInfo[]>;
     protected initializeServerAdapter(): Promise<NodeServerAdapterResult>;
-    start(): Promise<NodeServerInstance | void>;
+    protected bootServer(): Promise<NodeServerInstance | void>;
     fetch(request: Request): Promise<Response>;
     attachWebSocketUpgrades(httpServer: import('node:http').Server, options?: {
         passthroughUnmatched?: boolean;

package/src/adapters/node/create-app.js

@@ -1,109 +1,134 @@
-import { appLogger } from "../../global/app-logger.js";
-import { SharedApplicationAdapter } from "../shared/application-adapter.js";
-import { resolveRuntimeBinding } from "../shared/runtime-app-bootstrap.js";
-import { createNodeServerAdapter } from "./server-adapter.js";
-import { NodeHttpRequestBridge } from "./http-request-bridge.js";
-import { NodeRuntimeHost } from "./runtime-host.js";
-class NodeEcopagesApp extends SharedApplicationAdapter {
-  serverAdapter;
-  server = null;
-  runtimeOrigin = "";
-  stopped = false;
-  runtimeHost;
-  constructor(options, dependencies) {
-    super(options);
-    this.runtimeHost = dependencies.runtimeHost;
-  }
-  createServerAdapter(params) {
-    return createNodeServerAdapter(params);
-  }
-  async stop(force = true) {
-    if (this.stopped) {
-      return;
+import { appLogger } from '../../global/app-logger.js';
+import { SharedApplicationAdapter } from '../shared/runtime/application-adapter.js';
+import { resolveRuntimeBinding, resolveStaticRuntimeMode } from '../shared/runtime/runtime-app-bootstrap.js';
+import { createNodeServerAdapter } from './server-adapter.js';
+import { NodeHttpRequestBridge } from './http-request-bridge.js';
+import { NodeRuntimeHost } from './runtime-host.js';
+import { hostOwnsDevClient } from '../../dev/dev-client-ownership.js';
+import { startupTrace } from '../../diagnostics/startup-trace.js';
+import { resolveAppStartRoutes } from '../../utils/ecopages-route-info.js';
+export class NodeEcopagesApp extends SharedApplicationAdapter {
+    serverAdapter;
+    server = null;
+    runtimeOrigin = '';
+    stopped = false;
+    runtimeHost;
+    constructor(options, dependencies) {
+        super(options, 'Node');
+        this.runtimeHost = dependencies.runtimeHost;
     }
-    if (this.server) {
-      const activeServer = this.server;
-      this.server = null;
-      await this.runtimeHost.stop(activeServer, { force });
+    createServerAdapter(params) {
+        return createNodeServerAdapter(params);
     }
-    if (this.serverAdapter) {
-      await this.serverAdapter.dispose();
+    async stop(force = true) {
+        if (this.stopped) {
+            return;
+        }
+        if (this.server) {
+            const activeServer = this.server;
+            this.server = null;
+            await this.runtimeHost.stop(activeServer, { force });
+        }
+        if (this.serverAdapter) {
+            await this.serverAdapter.dispose();
+        }
+        this.stopped = true;
     }
-    this.stopped = true;
-  }
-  async initializeServerAdapter() {
-    const binding = resolveRuntimeBinding({
-      cliArgs: this.cliArgs,
-      serverOptions: this.serverOptions
-    });
-    this.runtimeOrigin = binding.runtimeOrigin;
-    return this.createServerAdapter({
-      runtimeOrigin: this.runtimeOrigin,
-      appConfig: this.appConfig,
-      apiHandlers: this.apiHandlers,
-      staticRoutes: this.staticRoutes,
-      errorHandler: this.errorHandler,
-      websocketHandlers: this.websocketHandlers.size > 0 ? this.websocketHandlers : void 0,
-      options: { watch: binding.watch },
-      serveOptions: binding.serveOptions
-    });
-  }
-  async start() {
-    if (this.stopped) {
-      this.serverAdapter = void 0;
-      this.stopped = false;
+    async resolveAppRoutes() {
+        return resolveAppStartRoutes({
+            listStaticGenerationRoutes: this.serverAdapter?.listStaticGenerationRoutes,
+            runtimeOrigin: this.appConfig.baseUrl,
+        });
     }
-    if (!this.serverAdapter) {
-      this.serverAdapter = await this.initializeServerAdapter();
+    async initializeServerAdapter() {
+        const binding = resolveRuntimeBinding({
+            cliArgs: this.cliArgs,
+            serverOptions: this.serverOptions,
+        });
+        this.runtimeOrigin = binding.runtimeOrigin;
+        return this.createServerAdapter({
+            runtimeOrigin: this.runtimeOrigin,
+            appConfig: this.appConfig,
+            apiHandlers: this.apiHandlers,
+            staticRoutes: this.staticRoutes,
+            errorHandler: this.errorHandler,
+            websocketHandlers: this.websocketHandlers.size > 0 ? this.websocketHandlers : undefined,
+            options: { watch: binding.watch },
+            serveOptions: binding.serveOptions,
+            hostOwnsDevClient: hostOwnsDevClient(this.runtimeOptions),
+            deferRuntimeAssetSetup: resolveStaticRuntimeMode({
+                appConfig: this.appConfig,
+                cliArgs: this.cliArgs,
+            }).canBuildWithoutRuntimeServer,
+            allowPortFallback: binding.allowPortFallback,
+        });
     }
-    if (this.server) {
-      return this.server;
+    async bootServer() {
+        if (this.stopped) {
+            this.serverAdapter = undefined;
+            this.stopped = false;
+        }
+        if (!this.serverAdapter) {
+            this.serverAdapter = await this.initializeServerAdapter();
+        }
+        if (this.server) {
+            return this.server;
+        }
+        const { build, preview, force, serveOnly } = this.cliArgs;
+        if (preview && serveOnly) {
+            const previewOrigin = await this.serverAdapter.servePreviewOnly();
+            if (previewOrigin) {
+                await this.notifyListening(previewOrigin);
+            }
+            return;
+        }
+        if (build || preview) {
+            appLogger.debugTime('Building static pages');
+            const previewOrigin = await this.serverAdapter.buildStatic({ preview, force });
+            appLogger.debugTimeEnd('Building static pages');
+            if (preview && previewOrigin) {
+                await this.notifyListening(previewOrigin);
+            }
+            if (build) {
+                process.exit(0);
+            }
+            return;
+        }
+        const serveOptions = this.serverAdapter.getServerOptions();
+        startupTrace.beginServerListen();
+        this.server = await this.runtimeHost.start({
+            serveOptions,
+            handleRequest: async (request) => await this.serverAdapter.handleRequest(request),
+            onError: async () => { },
+        });
+        this.runtimeOrigin = this.runtimeHost.getOrigin(this.server, serveOptions);
+        await this.serverAdapter.completeInitialization(this.server);
+        await this.notifyListening(this.runtimeOrigin);
+        return this.server;
     }
-    const { build, preview, force } = this.cliArgs;
-    if (build || preview) {
-      appLogger.debugTime("Building static pages");
-      await this.serverAdapter.buildStatic({ preview, force });
-      appLogger.debugTimeEnd("Building static pages");
-      if (build) {
-        process.exit(0);
-      }
-      return;
+    async fetch(request) {
+        if (!this.serverAdapter) {
+            this.serverAdapter = await this.initializeServerAdapter();
+        }
+        return this.serverAdapter.handleRequest(request);
     }
-    const serveOptions = this.serverAdapter.getServerOptions();
-    this.server = await this.runtimeHost.start({
-      serveOptions,
-      handleRequest: async (request) => await this.serverAdapter.handleRequest(request),
-      onError: async () => {
-      }
-    });
-    this.runtimeOrigin = this.runtimeHost.getOrigin(this.server, serveOptions);
-    await this.serverAdapter.completeInitialization(this.server);
-    appLogger.info(`Node server running at ${this.runtimeOrigin}`);
-    return this.server;
-  }
-  async fetch(request) {
-    if (!this.serverAdapter) {
-      this.serverAdapter = await this.initializeServerAdapter();
+    async attachWebSocketUpgrades(httpServer, options) {
+        if (!this.serverAdapter) {
+            this.serverAdapter = await this.initializeServerAdapter();
+        }
+        if (!this.server) {
+            this.server = httpServer;
+            await this.serverAdapter.completeInitialization(httpServer);
+            return;
+        }
+        this.serverAdapter.attachUserWebSocketUpgrades(httpServer, options);
     }
-    return this.serverAdapter.handleRequest(request);
-  }
-  async attachWebSocketUpgrades(httpServer, options) {
-    if (!this.serverAdapter) {
-      this.serverAdapter = await this.initializeServerAdapter();
-    }
-    this.serverAdapter.attachUserWebSocketUpgrades(httpServer, options);
-  }
 }
-async function createNodeApp(options) {
-  return new NodeEcopagesApp(options, {
-    runtimeHost: new NodeRuntimeHost(new NodeHttpRequestBridge())
-  });
+export async function createNodeApp(options) {
+    return new NodeEcopagesApp(options, {
+        runtimeHost: new NodeRuntimeHost(new NodeHttpRequestBridge()),
+    });
 }
-async function createApp(options) {
-  return createNodeApp(options);
+export async function createApp(options) {
+    return createNodeApp(options);
 }
-export {
-  NodeEcopagesApp,
-  createApp,
-  createNodeApp
-};