@warp-drive/holodeck 0.0.0-beta.2 → 0.0.0-beta.20

package/server/index.js

@@ -1,16 +1,74 @@
-import { serve } from '@hono/node-server';
+/* global Bun */
+import chalk from 'chalk';
 import { Hono } from 'hono';
-import { cors } from 'hono/cors';
+import { serve } from '@hono/node-server';
+import { createSecureServer } from 'node:http2';
 import { logger } from 'hono/logger';
+import { HTTPException } from 'hono/http-exception';
+import { cors } from 'hono/cors';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
-import http2 from 'node:http2';
-import { dirname } from 'node:path';
 import zlib from 'node:zlib';
-import { fileURLToPath } from 'url';
-import { HTTPException } from 'hono/http-exception';
+import { homedir } from 'os';
+import path from 'path';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const isBun = typeof Bun !== 'undefined';
+const DEBUG =
+  process.env.DEBUG?.includes('wd:holodeck') || process.env.DEBUG === '*' || process.env.DEBUG?.includes('wd:*');
+
+async function getCertInfo() {
+  let CERT_PATH = process.env.HOLODECK_SSL_CERT_PATH;
+  let KEY_PATH = process.env.HOLODECK_SSL_KEY_PATH;
+
+  if (!CERT_PATH) {
+    CERT_PATH = path.join(homedir(), 'holodeck-localhost.pem');
+    process.env.HOLODECK_SSL_CERT_PATH = CERT_PATH;
+
+    console.log(
+      `HOLODECK_SSL_CERT_PATH was not found in the current environment. Setting it to default value of ${CERT_PATH}`
+    );
+  }
+
+  if (!KEY_PATH) {
+    KEY_PATH = path.join(homedir(), 'holodeck-localhost-key.pem');
+    process.env.HOLODECK_SSL_KEY_PATH = KEY_PATH;
+
+    console.log(
+      `HOLODECK_SSL_KEY_PATH was not found in the current environment. Setting it to default value of ${KEY_PATH}`
+    );
+  }
+
+  if (isBun) {
+    const CERT = Bun.file(CERT_PATH);
+    const KEY = Bun.file(KEY_PATH);
+
+    if (!(await CERT.exists()) || !(await KEY.exists())) {
+      throw new Error(
+        'SSL certificate or key not found, you may need to run `pnpm dlx @warp-drive/holodeck ensure-cert`'
+      );
+    }
+
+    return {
+      CERT_PATH,
+      KEY_PATH,
+      CERT: await CERT.text(),
+      KEY: await KEY.text(),
+    };
+  } else {
+    if (!fs.existsSync(CERT_PATH) || !fs.existsSync(KEY_PATH)) {
+      throw new Error(
+        'SSL certificate or key not found, you may need to run `pnpm dlx @warp-drive/holodeck ensure-cert`'
+      );
+    }
+
+    return {
+      CERT_PATH,
+      KEY_PATH,
+      CERT: fs.readFileSync(CERT_PATH, 'utf8'),
+      KEY: fs.readFileSync(KEY_PATH, 'utf8'),
+    };
+  }
+}
 
 const DEFAULT_PORT = 1135;
 const BROTLI_OPTIONS = {
@@ -46,7 +104,7 @@ function getNiceUrl(url) {
 */
 function generateFilepath(options) {
   const { body } = options;
-  const bodyHash = body ? crypto.createHash('md5').update(body).digest('hex') : null;
+  const bodyHash = body ? crypto.createHash('md5').update(JSON.stringify(body)).digest('hex') : null;
   const cacheDir = generateFileDir(options);
   return `${cacheDir}/${bodyHash ? `${bodyHash}-` : 'res'}`;
 }
@@ -55,10 +113,14 @@ function generateFileDir(options) {
   return `${projectRoot}/.mock-cache/${testId}/${method}-${testRequestNumber}-${url}`;
 }
 
-function replayRequest(context, cacheKey) {
-  let meta;
+async function replayRequest(context, cacheKey) {
+  let metaJson;
   try {
-    meta = fs.readFileSync(`${cacheKey}.meta.json`, 'utf-8');
+    if (isBun) {
+      metaJson = await Bun.file(`${cacheKey}.meta.json`).json();
+    } else {
+      metaJson = JSON.parse(fs.readFileSync(`${cacheKey}.meta.json`, 'utf8'));
+    }
   } catch (e) {
     context.header('Content-Type', 'application/vnd.api+json');
     context.status(400);
@@ -69,18 +131,23 @@ function replayRequest(context, cacheKey) {
             status: '400',
             code: 'MOCK_NOT_FOUND',
             title: 'Mock not found',
-            detail: `No mock found for ${context.req.method} ${context.req.url}. You may need to record a mock for this request.`,
+            detail: `No meta was found for ${context.req.method} ${context.req.url}. You may need to record a mock for this request.`,
           },
         ],
       })
     );
   }
 
-  const metaJson = JSON.parse(meta);
   const bodyPath = `${cacheKey}.body.br`;
+  const bodyInit =
+    metaJson.status !== 204 && metaJson.status < 500
+      ? isBun
+        ? Bun.file(bodyPath)
+        : fs.createReadStream(bodyPath)
+      : '';
 
   const headers = new Headers(metaJson.headers || {});
-  const bodyInit = metaJson.status !== 204 && metaJson.status < 500 ? fs.createReadStream(bodyPath) : '';
+  // @ts-expect-error - createReadStream is supported in node
   const response = new Response(bodyInit, {
     status: metaJson.status,
     statusText: metaJson.statusText,
@@ -96,107 +163,199 @@ function replayRequest(context, cacheKey) {
 
 function createTestHandler(projectRoot) {
   const TestHandler = async (context) => {
-    const { req } = context;
+    try {
+      const { req } = context;
 
-    const testId = req.query('__xTestId');
-    const testRequestNumber = req.query('__xTestRequestNumber');
-    const niceUrl = getNiceUrl(req.url);
+      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 (!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: body ? JSON.stringify(body) : null,
+          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 });
 
-    if (!testRequestNumber) {
+        if (isBun) {
+          const newMetaFile = Bun.file(`${cacheKey}.meta.json`);
+          await newMetaFile.write(JSON.stringify({ url, status, statusText, headers, method, requestBody: body }));
+          const newBodyFile = Bun.file(`${cacheKey}.body.br`);
+          await newBodyFile.write(compressedResponse);
+        } else {
+          fs.writeFileSync(
+            `${cacheKey}.meta.json`,
+            JSON.stringify({ url, status, statusText, headers, method, requestBody: body })
+          );
+          fs.writeFileSync(`${cacheKey}.body.br`, compressedResponse);
+        }
+
+        context.status(204);
+        return context.body(null);
+      } else {
+        const body = req.body;
+        const cacheKey = generateFilepath({
+          projectRoot,
+          testId,
+          url: niceUrl,
+          method: req.method,
+          body: body ? JSON.stringify(body) : null,
+          testRequestNumber,
+        });
+        return replayRequest(context, cacheKey);
+      }
+    } catch (e) {
+      if (e instanceof HTTPException) {
+        throw e;
+      }
       context.header('Content-Type', 'application/vnd.api+json');
-      context.status(400);
+      context.status(500);
       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' },
+              status: '500',
+              code: 'MOCK_SERVER_ERROR',
+              title: 'Mock Server Error during Request',
+              detail: e.message,
             },
           ],
         })
       );
     }
-
-    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: body ? JSON.stringify(body) : null,
-        testRequestNumber,
-      });
-      // 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';
-
-      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 }, null, 2)
-      );
-      fs.writeFileSync(`${cacheKey}.body.br`, compress(JSON.stringify(response)));
-      context.status(204);
-      return context.body(null);
-    } else {
-      const body = await req.text();
-      const cacheKey = generateFilepath({
-        projectRoot,
-        testId,
-        url: niceUrl,
-        method: req.method,
-        body,
-        testRequestNumber,
-      });
-      return replayRequest(context, cacheKey);
-    }
   };
 
   return TestHandler;
 }
 
+export function startNodeServer() {
+  const args = process.argv.slice();
+
+  if (!isBun && args.length) {
+    const options = JSON.parse(args[2]);
+    _createServer(options);
+  }
+}
+
+export function startWorker() {
+  // listen for launch message
+  globalThis.onmessage = async (event) => {
+    const { options } = event.data;
+
+    const { server } = await _createServer(options);
+
+    // listen for messages
+    globalThis.onmessage = (event) => {
+      const message = event.data;
+      if (message === 'end') {
+        server.close();
+        globalThis.close();
+      }
+    };
+  };
+}
+
 /*
 { port?: number, projectRoot: string }
 */
-export function createServer(options) {
+export async function createServer(options, useBun = false) {
+  if (!useBun) {
+    const CURRENT_FILE = new URL(import.meta.url).pathname;
+    const START_FILE = path.join(CURRENT_FILE, '../start-node.js');
+    const server = Bun.spawn(['node', '--experimental-default-type=module', START_FILE, JSON.stringify(options)], {
+      env: process.env,
+      cwd: process.cwd(),
+      stdin: 'inherit',
+      stdout: 'inherit',
+      stderr: 'inherit',
+    });
+
+    return {
+      terminate() {
+        server.kill();
+        // server.unref();
+      },
+    };
+  }
+
+  const worker = new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
+
+  worker.postMessage({
+    type: 'launch',
+    options,
+  });
+
+  return worker;
+}
+
+async function _createServer(options) {
+  const { CERT, KEY } = await getCertInfo();
   const app = new Hono();
-  app.use('*', logger());
+  if (DEBUG) {
+    app.use('*', logger());
+  }
   app.use(
     '*',
     cors({
@@ -211,18 +370,70 @@ export function createServer(options) {
   );
   app.all('*', createTestHandler(options.projectRoot));
 
-  serve({
+  const server = serve({
+    overrideGlobalObjects: !isBun,
     fetch: app.fetch,
-    createServer: (_, requestListener) => {
-      return http2.createSecureServer(
-        {
-          key: fs.readFileSync(`${__dirname}/localhost-key.pem`),
-          cert: fs.readFileSync(`${__dirname}/localhost.pem`),
-        },
-        requestListener
-      );
+    serverOptions: {
+      key: KEY,
+      cert: CERT,
     },
+    createServer: createSecureServer,
     port: options.port ?? DEFAULT_PORT,
-    hostname: 'localhost',
+    hostname: options.hostname ?? 'localhost',
   });
+
+  console.log(
+    `\tMock server running at ${chalk.yellow('https://') + chalk.magenta((options.hostname ?? 'localhost') + ':') + chalk.yellow(options.port ?? DEFAULT_PORT)}`
+  );
+
+  return { app, server };
 }
+
+/** @type {Map<string, Awaited<ReturnType<typeof createServer>>>} */
+const servers = new Map();
+
+export default {
+  async launchProgram(config = {}) {
+    const projectRoot = process.cwd();
+    const name = await import(path.join(projectRoot, 'package.json'), { with: { type: 'json' } }).then(
+      (pkg) => pkg.name
+    );
+    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(
+            isBun ? 'bun@' + Bun.version : 'node'
+          )}`
+        )
+    );
+    console.log(chalk.grey(`\n\tStarting Holodeck Subroutines (mode:${chalk.cyan(isBun ? 'bun' : 'node')})`));
+
+    if (servers.has(projectRoot)) {
+      throw new Error(`Holodeck is already running for project '${name}' at '${projectRoot}'`);
+    }
+
+    // toggle to true if Bun fixes CORS support for HTTP/2
+    const project = await createServer(options, false);
+    servers.set(projectRoot, project);
+  },
+  async endProgram() {
+    console.log(chalk.grey(`\n\tEnding Holodeck Subroutines (mode:${chalk.cyan(isBun ? 'bun' : 'node')})`));
+    const projectRoot = process.cwd();
+
+    if (!servers.has(projectRoot)) {
+      const name = require(path.join(projectRoot, 'package.json')).name;
+      console.log(chalk.red(`\n\nHolodeck was not running for project '${name}' at '${projectRoot}'\n\n`));
+      return;
+    }
+
+    const project = servers.get(projectRoot);
+    servers.delete(projectRoot);
+    project.terminate();
+    console.log(chalk.grey(`\n\tHolodeck program ended`));
+  },
+};

package/server/start-node.js

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

package/server/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "include": ["."],
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["bun-types"],
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true
+  }
+}

package/server/worker.js

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

package/bin/cmd/_start.js

@@ -1,3 +0,0 @@
-import pm2 from './pm2.js';
-
-await pm2('start', process.argv.slice(2));

package/bin/cmd/_stop.js

@@ -1,3 +0,0 @@
-import pm2 from './pm2.js';
-
-await pm2('stop', process.argv.slice(2));

package/bin/cmd/pm2.js

@@ -1,38 +0,0 @@
-/* eslint-disable no-console */
-/* global Bun, globalThis */
-const { process } = globalThis;
-import pm2 from 'pm2';
-import fs from 'fs';
-
-export default async function pm2Delegate(cmd, _args) {
-  const pkg = JSON.parse(fs.readFileSync('./package.json'), 'utf8');
-
-  return new Promise((resolve, reject) => {
-    pm2.connect((err) => {
-      if (err) {
-        console.log('not able to connect to pm2');
-        console.error(err);
-        process.exit(2);
-      }
-
-      const options = {
-        script: './holodeck.mjs',
-        name: pkg.name + '::holodeck',
-        cwd: process.cwd(),
-        args: cmd === 'start' ? '-f' : '',
-      };
-
-      pm2[cmd](cmd === 'start' ? options : options.name, (err, apps) => {
-        pm2.disconnect(); // Disconnects from PM2
-        if (err) {
-          console.log(`not able to ${cmd} pm2 for ${options.name}`);
-          console.error(err);
-          reject(err);
-        } else {
-          console.log(`pm2 ${cmd} successful for ${options.name}`);
-          resolve();
-        }
-      });
-    });
-  });
-}

package/bin/cmd/run.js

@@ -1,50 +0,0 @@
-/* eslint-disable no-console */
-/* global Bun, globalThis */
-const isBun = typeof Bun !== 'undefined';
-const { process } = globalThis;
-import { spawn } from './spawn.js';
-import fs from 'fs';
-
-export default async function run(args) {
-  const pkg = JSON.parse(fs.readFileSync('./package.json'), 'utf8');
-  const cmd = args[0];
-  const isPkgScript = pkg.scripts[cmd];
-
-  if (isBun) {
-    await spawn(['bun', 'run', 'holodeck:start-program']);
-
-    let exitCode = 0;
-    try {
-      await spawn(['bun', 'run', ...args]);
-    } catch (e) {
-      exitCode = e;
-    }
-    await spawn(['bun', 'run', 'holodeck:end-program']);
-    if (exitCode !== 0) {
-      process.exit(exitCode);
-    }
-    return;
-  } else {
-    await spawn(['pnpm', 'run', 'holodeck:start-program']);
-
-    let exitCode = 0;
-    try {
-      if (isPkgScript) {
-        const cmdArgs = pkg.scripts[cmd].split(' ');
-        if (args.length > 1) {
-          cmdArgs.push(...args.slice(1));
-        }
-        console.log({ cmdArgs });
-        await spawn(cmdArgs);
-      } else {
-        await spawn(['pnpm', 'exec', ...args]);
-      }
-    } catch (e) {
-      exitCode = e;
-    }
-    await spawn(['pnpm', 'run', 'holodeck:end-program']);
-    if (exitCode !== 0) {
-      process.exit(exitCode);
-    }
-  }
-}

package/bin/cmd/spawn.js

@@ -1,40 +0,0 @@
-/* eslint-disable no-console */
-/* global Bun, globalThis */
-const isBun = typeof Bun !== 'undefined';
-
-export async function spawn(args, options) {
-  if (isBun) {
-    const proc = Bun.spawn(args, {
-      env: process.env,
-      cwd: process.cwd(),
-      stdout: 'inherit',
-      stderr: 'inherit',
-    });
-    await proc.exited;
-    if (proc.exitCode !== 0) {
-      throw proc.exitCode;
-    }
-    return;
-  }
-
-  const { spawn } = await import('node:child_process');
-
-  // eslint-disable-next-line no-inner-declarations
-  function pSpawn(cmd, args, opts) {
-    return new Promise((resolve, reject) => {
-      const proc = spawn(cmd, args, opts);
-      proc.on('exit', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(code);
-        }
-      });
-    });
-  }
-
-  await pSpawn(args.shift(), args, {
-    stdio: 'inherit',
-    shell: true,
-  });
-}