@warp-drive/holodeck 0.1.0-alpha.15 → 0.1.0-alpha.17

package/README.md

@@ -225,7 +225,7 @@ holodeck can be launched and cleaned up using the lifecycle hooks in the launch
 for diagnostic in `diagnostic.js`:
 
 ```ts
-import launch from '@warp-drive/diagnostic/server/default-setup.js';
+import { launch } from '@warp-drive/diagnostic/server';
 import holodeck from '@warp-drive/holodeck';
 
 await launch({

package/declarations/index.d.ts

@@ -1,6 +1,5 @@
 import type { Handler, NextFn } from "@warp-drive/core/request";
 import type { RequestContext, StructuredDataDocument } from "@warp-drive/core/types/request";
-import type { MinimumAdapterInterface } from "@warp-drive/legacy/compat";
 import type { Store } from "@warp-drive/legacy/store";
 import type { ScaffoldGenerator } from "./mock.js";
 /**
@@ -37,10 +36,6 @@ export declare class MockServerHandler implements Handler {
 	constructor(owner: object);
 	request<T>(context: RequestContext, next: NextFn<T>): Promise<StructuredDataDocument<T>>;
 }
-interface HasAdapterForFn {
-	adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
-	adapterFor(this: Store, modelName: string, _allowMissing?: true): MinimumAdapterInterface | undefined;
-}
 /**
 * Creates an adapterFor function that wraps the provided adapterFor function
 * to override the adapter's _fetchRequest method to route requests through
@@ -48,11 +43,10 @@ interface HasAdapterForFn {
 *
 * @param owner - The test context object used to retrieve the test ID.
 */
-export declare function createAdapterFor(owner: object, store: HasAdapterForFn): HasAdapterForFn["adapterFor"];
+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>;
-export {};

package/dist/index.js

@@ -5,7 +5,7 @@ import { SHOULD_RECORD } from '@warp-drive/core/build-config/env';
  * @mergeModuleWith <project>
  */
 const TEST_IDS = new WeakMap();
-let HOST = 'https://localhost:1135/';
+let HOST = '/';
 
 /**
  * @public
@@ -126,14 +126,38 @@ function setupHolodeckFetch(owner, request) {
   }
   const queryForTest = `${firstChar}__xTestId=${test.id}&__xTestRequestNumber=${test.request[method][url]++}`;
   request.url = url + queryForTest;
+  request.method = method;
   request.mode = 'cors';
   request.credentials = 'omit';
   request.referrerPolicy = '';
+
+  // since holodeck currently runs on a separate port
+  // and we don't want to trigger cors pre-flight
+  // we convert PUT to POST to keep the request in the
+  // "simple" cors category.
+  // if (request.method === 'PUT') {
+  //   request.method = 'POST';
+  // }
+
+  const headers = new Headers(request.headers);
+  if (headers.has('Content-Type')) {
+    // under the rules of simple-cors, content-type can only be
+    // one of three things, none of which are what folks typically
+    // set this to. Since holodeck always expects body to be JSON
+    // this "just works".
+    headers.set('Content-Type', 'text/plain');
+    request.headers = headers;
+  }
   return {
     request,
     queryForTest
   };
 }
+function upgradeStore(store) {
+  if (typeof store.adapterFor !== 'function') {
+    throw new Error('Store is not compatible with Holodeck. Missing adapterFor method.');
+  }
+}
 
 /**
  * Creates an adapterFor function that wraps the provided adapterFor function
@@ -142,11 +166,11 @@ function setupHolodeckFetch(owner, request) {
  *
  * @param owner - The test context object used to retrieve the test ID.
  */
-function createAdapterFor(owner, store) {
-  // eslint-disable-next-line @typescript-eslint/unbound-method
-  const adapterFor = store.adapterFor;
-  return function holodeckAdapterFor(modelName, _allowMissing) {
-    const adapter = adapterFor.call(this, modelName, _allowMissing);
+function installAdapterFor(owner, store) {
+  upgradeStore(store);
+  const fn = store.adapterFor;
+  function holodeckAdapterFor(modelName, _allowMissing) {
+    const adapter = fn.call(this, modelName, _allowMissing);
     if (adapter) {
       if (!adapter.hasOverriddenFetch) {
         adapter.hasOverriddenFetch = true;
@@ -164,7 +188,8 @@ function createAdapterFor(owner, store) {
       }
     }
     return adapter;
-  };
+  }
+  store.adapterFor = holodeckAdapterFor;
 }
 
 /**
@@ -209,4 +234,4 @@ async function mock(owner, generate, isRecording) {
   }
 }
 
-export { MockServerHandler, createAdapterFor, getIsRecording, mock, setConfig, setIsRecording, setTestId };
+export { MockServerHandler, getIsRecording, installAdapterFor, mock, setConfig, setIsRecording, setTestId };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@warp-drive/holodeck",
   "description": "⚡️ Simple, Fast HTTP Mocking for Tests",
-  "version": "0.1.0-alpha.15",
+  "version": "0.1.0-alpha.17",
   "license": "MIT",
   "author": "Chris Thoburn <runspired@users.noreply.github.com>",
   "repository": {
@@ -39,9 +39,9 @@
     "ensure-cert": "./server/ensure-cert.js"
   },
   "peerDependencies": {
-    "@warp-drive/utilities": "5.8.0-alpha.15",
-    "@warp-drive/legacy": "5.8.0-alpha.15",
-    "@warp-drive/core": "5.8.0-alpha.15"
+    "@warp-drive/utilities": "5.8.0-alpha.17",
+    "@warp-drive/legacy": "5.8.0-alpha.17",
+    "@warp-drive/core": "5.8.0-alpha.17"
   },
   "peerDependenciesMeta": {
     "@warp-drive/utilities": {
@@ -57,10 +57,10 @@
     "@babel/preset-env": "^7.28.3",
     "@babel/preset-typescript": "^7.27.1",
     "@babel/runtime": "^7.28.3",
-    "@warp-drive/utilities": "5.8.0-alpha.15",
-    "@warp-drive/legacy": "5.8.0-alpha.15",
-    "@warp-drive/core": "5.8.0-alpha.15",
-    "@warp-drive/internal-config": "5.8.0-alpha.15",
+    "@warp-drive/utilities": "5.8.0-alpha.17",
+    "@warp-drive/legacy": "5.8.0-alpha.17",
+    "@warp-drive/core": "5.8.0-alpha.17",
+    "@warp-drive/internal-config": "5.8.0-alpha.17",
     "vite": "^7.1.3"
   },
   "exports": {

package/server/bun-worker.js

@@ -0,0 +1,3 @@
+import { startWorker } from './bun.js';
+
+startWorker();

package/server/bun.js

@@ -0,0 +1,393 @@
+import chalk from 'chalk';
+import { Hono } from 'hono';
+import { createSecureServer } from 'node:http2';
+import { logger } from 'hono/logger';
+import { HTTPException } from 'hono/http-exception';
+import { cors } from 'hono/cors';
+import fs from 'node:fs';
+import path from 'path';
+import { Worker, threadId, parentPort } from 'node:worker_threads';
+import {
+  compress,
+  createCloseHandler,
+  DEFAULT_PORT,
+  generateFileDir,
+  generateFilepath,
+  getCertInfo,
+  getNiceUrl,
+} from './utils.js';
+
+async function replayRequest(context, cacheKey) {
+  let metaJson;
+  try {
+    metaJson = JSON.parse(fs.readFileSync(`${cacheKey}.meta.json`, 'utf8'));
+  } catch (e) {
+    context.header('Content-Type', 'application/vnd.api+json');
+    context.status(400);
+    return context.body(
+      JSON.stringify({
+        errors: [
+          {
+            status: '400',
+            code: 'MOCK_NOT_FOUND',
+            title: 'Mock not found',
+            detail: `No meta was found for ${context.req.method} ${context.req.url}. The expected cacheKey was ${cacheKey}. You may need to record a mock for this request.`,
+          },
+        ],
+      })
+    );
+  }
+
+  try {
+    const bodyPath = `${cacheKey}.body.br`;
+    const bodyInit = metaJson.status !== 204 && metaJson.status < 500 ? fs.createReadStream(bodyPath) : '';
+
+    const headers = new Headers(metaJson.headers || {});
+    // @ts-expect-error - createReadStream is supported in node
+    const response = new Response(bodyInit, {
+      status: metaJson.status,
+      statusText: metaJson.statusText,
+      headers,
+    });
+
+    if (metaJson.status > 400) {
+      throw new HTTPException(metaJson.status, { res: response, message: metaJson.statusText });
+    }
+
+    return response;
+  } catch (e) {
+    if (e instanceof HTTPException) {
+      throw e;
+    }
+    context.header('Content-Type', 'application/vnd.api+json');
+    context.status(500);
+    return context.body(
+      JSON.stringify({
+        errors: [
+          {
+            status: '500',
+            code: 'MOCK_SERVER_ERROR',
+            title: 'Mock Replay Failed',
+            detail: `Failed to create the response for ${context.req.method} ${context.req.url}.\n\n\n${e.message}\n${e.stack}`,
+          },
+        ],
+      })
+    );
+  }
+}
+
+function createTestHandler(projectRoot) {
+  const TestHandler = async (context) => {
+    try {
+      const { req } = context;
+
+      const testId = req.query('__xTestId');
+      const testRequestNumber = req.query('__xTestRequestNumber');
+      const niceUrl = getNiceUrl(req.url);
+
+      if (!testId) {
+        context.header('Content-Type', 'application/vnd.api+json');
+        context.status(400);
+        return context.body(
+          JSON.stringify({
+            errors: [
+              {
+                status: '400',
+                code: 'MISSING_X_TEST_ID_HEADER',
+                title: 'Request to the http mock server is missing the `X-Test-Id` header',
+                detail:
+                  "The `X-Test-Id` header is used to identify the test that is making the request to the mock server. This is used to ensure that the mock server is only used for the test that is currently running. If using @ember-data/request add import { MockServerHandler } from '@warp-drive/holodeck'; to your request handlers.",
+                source: { header: 'X-Test-Id' },
+              },
+            ],
+          })
+        );
+      }
+
+      if (!testRequestNumber) {
+        context.header('Content-Type', 'application/vnd.api+json');
+        context.status(400);
+        return context.body(
+          JSON.stringify({
+            errors: [
+              {
+                status: '400',
+                code: 'MISSING_X_TEST_REQUEST_NUMBER_HEADER',
+                title: 'Request to the http mock server is missing the `X-Test-Request-Number` header',
+                detail:
+                  "The `X-Test-Request-Number` header is used to identify the request number for the current test. This is used to ensure that the mock server response is deterministic for the test that is currently running. If using @ember-data/request add import { MockServerHandler } from '@warp-drive/holodeck'; to your request handlers.",
+                source: { header: 'X-Test-Request-Number' },
+              },
+            ],
+          })
+        );
+      }
+
+      if (req.method === 'POST' && niceUrl === '__record') {
+        const payload = await req.json();
+        const { url, headers, method, status, statusText, body, response } = payload;
+        const cacheKey = generateFilepath({
+          projectRoot,
+          testId,
+          url,
+          method,
+          body,
+          testRequestNumber,
+        });
+        const compressedResponse = compress(JSON.stringify(response));
+        // allow Content-Type to be overridden
+        headers['Content-Type'] = headers['Content-Type'] || 'application/vnd.api+json';
+        // We always compress and chunk the response
+        headers['Content-Encoding'] = 'br';
+        // we don't cache since tests will often reuse similar urls for different payload
+        headers['Cache-Control'] = 'no-store';
+        // streaming requires Content-Length
+        headers['Content-Length'] = compressedResponse.length;
+
+        const cacheDir = generateFileDir({
+          projectRoot,
+          testId,
+          url,
+          method,
+          testRequestNumber,
+        });
+
+        fs.mkdirSync(cacheDir, { recursive: true });
+
+        fs.writeFileSync(
+          `${cacheKey}.meta.json`,
+          JSON.stringify({ url, status, statusText, headers, method, requestBody: body })
+        );
+        fs.writeFileSync(`${cacheKey}.body.br`, compressedResponse);
+
+        context.status(201);
+        return context.body(
+          JSON.stringify({
+            message: `Recorded ${method} ${url} for test ${testId} request #${testRequestNumber}`,
+            cacheKey,
+            cacheDir,
+          })
+        );
+      } else {
+        const body = req.raw.body ? await req.text() : null;
+        const cacheKey = generateFilepath({
+          projectRoot,
+          testId,
+          url: niceUrl,
+          method: req.method,
+          body: body ? body : null,
+          testRequestNumber,
+        });
+
+        // console.log(
+        //   `Replaying mock for ${req.method} ${niceUrl} (test: ${testId} request #${testRequestNumber}) from '${cacheKey}' if available`
+        // );
+        return replayRequest(context, cacheKey);
+      }
+    } catch (e) {
+      if (e instanceof HTTPException) {
+        console.log(`HTTPException Encountered`);
+        console.error(e);
+        throw e;
+      }
+      console.log(`500 MOCK_SERVER_ERROR Encountered`);
+      console.error(e);
+      context.header('Content-Type', 'application/vnd.api+json');
+      context.status(500);
+      return context.body(
+        JSON.stringify({
+          errors: [
+            {
+              status: '500',
+              code: 'MOCK_SERVER_ERROR',
+              title: 'Mock Server Error during Request',
+              detail: e.message,
+            },
+          ],
+        })
+      );
+    }
+  };
+
+  return TestHandler;
+}
+
+export async function startWorker() {
+  let close;
+  parentPort.postMessage('ready');
+  // listen for launch message
+  parentPort.on('message', async (event) => {
+    // console.log('worker message received', event);
+    if (typeof event === 'object' && event?.type === 'launch') {
+      // console.log('worker launching');
+      const { options } = event;
+      const result = await _createServer(options);
+      parentPort.postMessage({
+        type: 'launched',
+        protocol: 'https',
+        hostname: result.location.hostname,
+        port: result.location.port,
+      });
+      close = result.close;
+    }
+
+    if (event === 'end') {
+      // console.log('worker shutting down');
+      close();
+    }
+  });
+}
+
+/*
+{ port?: number, projectRoot: string }
+*/
+async function createServer(options) {
+  if (options.useWorker) {
+    // console.log('starting holodeck worker');
+    const worker = new Worker(new URL('./bun-worker.js', import.meta.url));
+
+    const started = new Promise((resolve) => {
+      worker.on('message', (v) => {
+        // console.log('worker message received', v);
+        if (v === 'ready') {
+          worker.postMessage({
+            type: 'launch',
+            options,
+          });
+        } else if (v.type === 'launched') {
+          // @ts-expect-error
+          worker.location = v;
+          resolve(worker);
+        }
+      });
+    });
+
+    await started;
+    console.log('\tworker booted');
+    return {
+      worker,
+      server: {
+        close() {
+          worker.postMessage('end');
+          worker.terminate();
+        },
+      },
+      // @ts-expect-error
+      location: worker.location,
+    };
+  }
+
+  return _createServer(options);
+}
+
+async function _createServer(options) {
+  const { CERT, KEY } = await getCertInfo();
+  const app = new Hono();
+  // app.use(logger());
+
+  app.use(
+    cors({
+      origin: (origin, context) => {
+        // console.log(context.req.raw.headers);
+        const result = origin.startsWith('http://localhost:') || origin.startsWith('https://localhost:') ? origin : '*';
+        // console.log(`CORS Origin: ${origin} => ${result}`);
+        return result;
+      },
+      allowHeaders: ['Accept', 'Content-Type'],
+      allowMethods: ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH'],
+      exposeHeaders: ['Content-Length', 'Content-Type'],
+      maxAge: 60_000,
+      credentials: false,
+    })
+  );
+  app.all('*', createTestHandler(options.projectRoot));
+
+  const location = {
+    port: options.port ?? DEFAULT_PORT,
+    hostname: options.hostname ?? 'localhost',
+  };
+
+  const server = Bun.serve({
+    fetch: app.fetch,
+    tls: {
+      key: KEY,
+      cert: CERT,
+    },
+    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`
+  );
+
+  if (typeof threadId === 'number' && threadId !== 0) {
+    parentPort.postMessage({
+      type: 'launched',
+      protocol: 'https',
+      hostname: location.hostname,
+      port: location.port,
+    });
+  }
+
+  if (typeof threadId === 'number' && threadId !== 0) {
+    const close = createCloseHandler(() => {
+      return server.stop();
+    });
+
+    return { app, server, location, close };
+  }
+
+  return {
+    app,
+    server,
+    location,
+    close: () => {
+      return server.stop();
+    },
+  };
+}
+
+export async function launchProgram(config = {}) {
+  const projectRoot = process.cwd();
+  const pkg = await import(path.join(projectRoot, 'package.json'), { with: { type: 'json' } });
+  const { name } = pkg.default ?? pkg;
+  if (!name) {
+    throw new Error(`Package name not found in package.json`);
+  }
+  const options = { name, projectRoot, ...config };
+  console.log(
+    chalk.grey(
+      `\n\t@${chalk.greenBright('warp-drive')}/${chalk.magentaBright(
+        'holodeck'
+      )} 🌅\n\t=================================\n`
+    ) +
+      chalk.grey(
+        `\n\tHolodeck Access Granted\n\t\tprogram: ${chalk.magenta(name)}\n\t\tsettings: ${chalk.green(
+          JSON.stringify(config).split('\n').join(' ')
+        )}\n\t\tdirectory: ${chalk.cyan(projectRoot)}\n\t\tengine: ${chalk.cyan('bun')}@${chalk.yellow(Bun.version)}\n`
+      )
+  );
+  console.log(chalk.grey(`\n\tStarting Holodeck Subroutines`));
+
+  const project = await createServer(options);
+
+  async function shutdown() {
+    console.log(chalk.grey(`\n\tEnding Holodeck Subroutines`));
+    project.close();
+    console.log(chalk.grey(`\n\tHolodeck program ended`));
+  }
+
+  const endProgram = createCloseHandler(shutdown);
+
+  return {
+    config: {
+      location: `https://${project.location.hostname}:${project.location.port}`,
+      port: project.location.port,
+      hostname: project.location.hostname,
+      protocol: 'https',
+      recordingPath: `/__record`,
+    },
+    endProgram,
+  };
+}

package/server/compat-shim.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import { stripVTControlCharacters } from 'util';
+const HOST_LOG_MESSAGE = `Serving Holodeck HTTP Mocks from`;
+const WORKER_DONE_LOG_MESSAGE = `worker booted`;
+const HTTPS_EXTRACT_MATCH = /https:\/\/([^:]+):(\d+)/;
+
+async function waitForBoot(server, useWorker = false) {
+  let port = null;
+  let hostname = null;
+  let done = false;
+
+  for await (const chunk of server.stdout) {
+    process.stdout.write(chunk);
+    const txt = new TextDecoder().decode(chunk);
+    if (txt.includes(HOST_LOG_MESSAGE)) {
+      const urlMatch = HTTPS_EXTRACT_MATCH.exec(stripVTControlCharacters(txt));
+      if (urlMatch) {
+        hostname = urlMatch[1];
+        port = parseInt(urlMatch[2], 10);
+      }
+      if (!useWorker) {
+        done = true;
+        break;
+      }
+    }
+    if (useWorker && txt.includes(WORKER_DONE_LOG_MESSAGE)) {
+      done = true;
+      break;
+    }
+  }
+
+  if (!done) {
+    throw new Error('Holodeck server failed to start');
+  }
+
+  if (!port || !hostname) {
+    throw new Error('Could not determine Holodeck server port');
+  }
+
+  return { port, hostname };
+}
+
+async function reprintLogs(server) {
+  for await (const chunk of server.stdout) {
+    process.stdout.write(chunk);
+
+    if (server.killed) {
+      break;
+    }
+  }
+}
+
+async function reprintErrors(server) {
+  for await (const chunk of server.stderr) {
+    process.stderr.write(chunk);
+
+    if (server.killed) {
+      break;
+    }
+  }
+}
+
+/**
+ * If we are launched with bun but still want to use node,
+ * this will spawn a child process to run the node server.
+ *
+ */
+export async function launchProgram(config = {}) {
+  const CURRENT_FILE = new URL(import.meta.url).pathname;
+  const START_FILE = path.join(CURRENT_FILE, '../node-compat-start.js');
+  const server = Bun.spawn(['node', START_FILE, JSON.stringify(config)], {
+    env: Object.assign({}, process.env, { FORCE_COLOR: 1 }),
+    cwd: process.cwd(),
+    stdin: 'ignore',
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+
+  const { hostname, port } = await waitForBoot(server, config.useWorker);
+  void reprintLogs(server);
+  void reprintErrors(server);
+
+  return {
+    config: {
+      location: `https://${hostname}:${port}`,
+      port,
+      hostname,
+      protocol: 'https',
+      recordingPath: `/__record`,
+    },
+    endProgram: () => {
+      server.kill();
+    },
+  };
+}