@warp-drive/holodeck 0.1.0-beta.1 → 0.1.0-beta.2

package/server/node.js

@@ -1,14 +1,16 @@
-import chalk from 'chalk';
-import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
-import { createSecureServer } from 'node:http2';
-import { logger } from 'hono/logger';
-import { HTTPException } from 'hono/http-exception';
+import { Hono } from 'hono';
 import { cors } from 'hono/cors';
+import { HTTPException } from 'hono/http-exception';
+import { logger } from 'hono/logger';
 import fs from 'node:fs';
-import path from 'path';
+import { createSecureServer } from 'node:http2';
+import { styleText } from 'node:util';
 import { Worker, threadId, parentPort } from 'node:worker_threads';
+import path from 'path';
+
 import {
+  bindWithRetry,
   compress,
   createCloseHandler,
   DEFAULT_PORT,
@@ -308,26 +310,28 @@ async function _createServer(options) {
     hostname: options.hostname ?? 'localhost',
   };
 
-  const server = serve({
-    overrideGlobalObjects: true,
-    fetch: app.fetch,
-    serverOptions: {
-      key: KEY,
-      cert: CERT,
-      // rejectUnauthorized: false,
-      // enableTrace: true,
-      // Allow HTTP/1.1 fallback for ALPN negotiation
-      // allowHTTP1: true,
-      // ALPNProtocols: ['h2', 'http/1.1', 'http/1.0'],
-      // origins: ['*'],
-    },
-    createServer: createSecureServer,
-    port: location.port,
-    hostname: location.hostname,
-  });
+  const server = await bindWithRetry(() =>
+    serve({
+      overrideGlobalObjects: true,
+      fetch: app.fetch,
+      serverOptions: {
+        key: KEY,
+        cert: CERT,
+        // rejectUnauthorized: false,
+        // enableTrace: true,
+        // Allow HTTP/1.1 fallback for ALPN negotiation
+        // allowHTTP1: true,
+        // ALPNProtocols: ['h2', 'http/1.1', 'http/1.0'],
+        // origins: ['*'],
+      },
+      createServer: createSecureServer,
+      port: location.port,
+      hostname: location.hostname,
+    })
+  );
 
   console.log(
-    `\tServing Holodeck HTTP Mocks from ${chalk.yellow('https://') + chalk.magenta(location.hostname + ':') + chalk.yellow(location.port)}\n`
+    `\tServing Holodeck HTTP Mocks from ${styleText('yellow', 'https://') + styleText('magenta', location.hostname + ':') + styleText('yellow', String(location.port))}\n`
   );
 
   if (typeof threadId === 'number' && threadId !== 0) {
@@ -363,27 +367,32 @@ export async function launchProgram(config = {}) {
   }
   const options = { name, projectRoot, ...config };
   console.log(
-    chalk.grey(
-      `\n\t@${chalk.greenBright('warp-drive')}/${chalk.magentaBright(
+    styleText(
+      'grey',
+      `\n\t@${styleText('greenBright', 'warp-drive')}/${styleText(
+        'magentaBright',
         'holodeck'
       )} 🌅\n\t=================================\n`
     ) +
-      chalk.grey(
-        `\n\tHolodeck Access Granted\n\t\tprogram: ${chalk.magenta(name)}\n\t\tsettings: ${chalk.green(
+      styleText(
+        'grey',
+        `\n\tHolodeck Access Granted\n\t\tprogram: ${styleText('magenta', name)}\n\t\tsettings: ${styleText(
+          'green',
           JSON.stringify(config).split('\n').join(' ')
-        )}\n\t\tdirectory: ${chalk.cyan(projectRoot)}\n\t\tengine: ${chalk.cyan(
+        )}\n\t\tdirectory: ${styleText('cyan', projectRoot)}\n\t\tengine: ${styleText(
+          'cyan',
           'node'
-        )}@${chalk.yellow(process.version)}\n`
+        )}@${styleText('yellow', process.version)}\n`
       )
   );
-  console.log(chalk.grey(`\n\tStarting Holodeck Subroutines`));
+  console.log(styleText('grey', `\n\tStarting Holodeck Subroutines`));
 
   const project = await createServer(options);
 
   async function shutdown() {
-    console.log(chalk.grey(`\n\tEnding Holodeck Subroutines`));
+    console.log(styleText('grey', `\n\tEnding Holodeck Subroutines`));
     project.server.close();
-    console.log(chalk.grey(`\n\tHolodeck program ended`));
+    console.log(styleText('grey', `\n\tHolodeck program ended`));
   }
 
   const endProgram = createCloseHandler(shutdown);

package/server/utils.js

@@ -127,3 +127,58 @@ export function createCloseHandler(cb) {
     cb();
   };
 }
+
+/**
+ * Binds a server created by `createServerFn()`, retrying on the same port if
+ * it's already in use.
+ *
+ * Holodeck's port is never renegotiated on conflict -- every test app's
+ * client-side test-helper derives holodeck's URL as `window.location.port +
+ * 1` (the diagnostic server's own port, plus one), so holodeck must bind
+ * exactly the port it was asked for or the browser can never find it.
+ * Instead, this retries the *same* port a few times with a short delay, to
+ * ride out the narrow window where a concurrently-starting sibling process's
+ * diagnostic server hasn't released this exact port yet (see
+ * packages/diagnostic/server/utils/port-lock.js for the reservation scheme
+ * that's supposed to prevent that from happening at all -- this is a
+ * defense-in-depth fallback for anything outside that convention).
+ *
+ * `createServerFn` must synchronously create the server and start binding,
+ * returning the server instance. Some implementations (Bun.serve) throw
+ * synchronously on a bind failure; others (Node's http/http2 `.listen()`,
+ * which is what @hono/node-server uses under the hood) bind asynchronously
+ * and emit an 'error' event on the returned server instead of throwing. This
+ * handles both.
+ */
+export async function bindWithRetry(createServerFn, { maxAttempts = 5, retryDelayMs = 150 } = {}) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      const server = createServerFn();
+      if (typeof server?.on !== 'function') {
+        // no event emitter to observe an async bind failure on -- the
+        // synchronous creation above already succeeded, so assume the bind
+        // did too (this is the Bun.serve path, which throws synchronously
+        // instead)
+        return server;
+      }
+      const bindError = await new Promise((resolve) => {
+        const onError = (e) => resolve(e);
+        server.once('error', onError);
+        setTimeout(() => {
+          server.off('error', onError);
+          resolve(null);
+        }, retryDelayMs);
+      });
+      if (!bindError) {
+        return server;
+      }
+      throw bindError;
+    } catch (e) {
+      if (e?.code !== 'EADDRINUSE' || attempt >= maxAttempts) {
+        throw e;
+      }
+      console.log(`\tPort in use, retrying bind (attempt ${attempt}/${maxAttempts})...`);
+      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+    }
+  }
+}

package/declarations/index.d.ts

@@ -1,52 +0,0 @@
-import type { Handler, NextFn } from "@warp-drive/core/request";
-import type { RequestContext, StructuredDataDocument } from "@warp-drive/core/types/request";
-import type { Store } from "@warp-drive/legacy/store";
-import type { ScaffoldGenerator } from "./mock.js";
-/**
-* @public
-*/
-export declare function setConfig({ host }: {
-	host: string;
-}): void;
-/**
-* @public
-*/
-export declare function setTestId(context: object, str: string | null): void;
-/**
-* @public
-*/
-export declare function setIsRecording(value: boolean): void;
-/**
-* @public
-*/
-export declare function getIsRecording(): boolean;
-/**
-* A request handler that intercepts requests and routes them through
-* the Holodeck mock server.
-*
-* This handler modifies the request URL to include test identifiers
-* and manages request counts for accurate mocking.
-*
-* Requires that the test context be configured with a testId using `setTestId`.
-*
-* @param owner - the test context object used to retrieve the test ID.
-*/
-export declare class MockServerHandler implements Handler {
-	owner: object;
-	constructor(owner: object);
-	request<T>(context: RequestContext, next: NextFn<T>): Promise<StructuredDataDocument<T>>;
-}
-/**
-* Creates an adapterFor function that wraps the provided adapterFor function
-* to override the adapter's _fetchRequest method to route requests through
-* the Holodeck mock server.
-*
-* @param owner - The test context object used to retrieve the test ID.
-*/
-export declare function installAdapterFor(owner: object, store: Store): void;
-/**
-* Mock a request by sending the scaffold to the mock server.
-*
-* @public
-*/
-export declare function mock(owner: object, generate: ScaffoldGenerator, isRecording?: boolean): Promise<void>;

package/declarations/mock.d.ts

@@ -1,85 +0,0 @@
-/**
-* @public
-*/
-export interface Scaffold {
-	status: number;
-	statusText?: string;
-	headers: Record<string, string>;
-	body: Record<string, string> | string | null;
-	method: string;
-	url: string;
-	response: Record<string, unknown>;
-}
-/**
-* @public
-*/
-export type ScaffoldGenerator = () => Scaffold;
-/**
-* @public
-*/
-export type ResponseGenerator = () => Record<string, unknown>;
-/**
-* Sets up Mocking for a GET request on the mock server
-* for the supplied url.
-*
-* The response body is generated by the supplied response function.
-*
-* Available options:
-* - status: the status code to return (default: 200)
-* - headers: the headers to return (default: {})
-* - body: the body to match against for the request (default: null)
-* - RECORD: whether to record the request (default: false)
-*
-* @param url the url to mock, relative to the mock server host (e.g. `users/1`)
-* @param response a function which generates the response to return
-* @param options status, headers for the response, body to match against for the request, and whether to record the request
-* @return
-*/
-export declare function GET(owner: object, url: string, response: ResponseGenerator, options?: Partial<Omit<Scaffold, "response" | "url" | "method">> & {
-	RECORD?: boolean;
-}): Promise<void>;
-/**
-* Mock a POST request
-*/
-export declare function POST(owner: object, url: string, response: ResponseGenerator, options?: Partial<Omit<Scaffold, "response" | "url" | "method">> & {
-	RECORD?: boolean;
-}): Promise<void>;
-/**
-* mock a PUT request
-*/
-export declare function PUT(owner: object, url: string, response: ResponseGenerator, options?: Partial<Omit<Scaffold, "response" | "url" | "method">> & {
-	RECORD?: boolean;
-}): Promise<void>;
-/**
-* mock a PATCH request
-*
-*/
-export declare function PATCH(owner: object, url: string, response: ResponseGenerator, options?: Partial<Omit<Scaffold, "response" | "url" | "method">> & {
-	RECORD?: boolean;
-}): Promise<void>;
-/**
-* mock a DELETE request
-*/
-export declare function DELETE(owner: object, url: string, response: ResponseGenerator, options?: Partial<Omit<Scaffold, "response" | "url" | "method">> & {
-	RECORD?: boolean;
-}): Promise<void>;
-/**
-* Sets up Mocking for a HEAD request on the mock server
-* for the supplied url.
-*
-* The response body is generated by the supplied response function.
-*
-* Available options:
-* - status: the status code to return (default: 200)
-* - headers: the headers to return (default: {})
-* - body: the body to match against for the request (default: null)
-* - RECORD: whether to record the request (default: false)
-*
-* @param url the url to mock, relative to the mock server host (e.g. `users/1`)
-* @param response a function which generates the response to return
-* @param options status, headers for the response, body to match against for the request, and whether to record the request
-* @return
-*/
-export declare function HEAD(owner: object, url: string, response: ResponseGenerator, options?: Partial<Omit<Scaffold, "response" | "url" | "method">> & {
-	RECORD?: boolean;
-}): Promise<void>;