@jaredwray/mockhttp 1.3.0 → 1.5.0

package/README.md

@@ -25,6 +25,8 @@ A simple HTTP server that can be used to mock HTTP responses for testing purpose
 - [Deploy via Docker](#deploy-via-docker)
 - [Deploy via Docker Compose](#deploy-via-docker-compose)
 - [Deploy via NodeJS](#deploy-via-nodejs)
+- [HTTPS Support](#https-support)
+- [HTTP/2 Support](#http2-support)
 - [Response Injection (Tap Feature)](#response-injection-tap-feature)
 - [Rate Limiting](#rate-limiting)
 - [Logging](#logging)
@@ -69,11 +71,180 @@ npm install @jaredwray/mockhttp --save
 then run `mockhttp` in your code.
 
 ```javascript
-import { mockhttp } from '@jaredwray/mockhttp';
-await mockhttp.start(); // start the server
+import { MockHttp } from '@jaredwray/mockhttp';
+const mock = new MockHttp();
+await mock.start(); // start the server
 const response = await fetch('http://localhost:3000/get');
 console.log(response);
-await mockhttp.stop(); // stop the server
+await mock.close(); // stop the server
+```
+
+# HTTPS Support
+
+MockHttp supports HTTPS with auto-generated self-signed certificates or your own custom certificates. No external dependencies are required — certificate generation uses only Node.js built-in `crypto`.
+
+## Auto-Generated Certificate
+
+The simplest way to enable HTTPS is to pass `https: true`. A self-signed certificate for `localhost` is generated automatically:
+
+```javascript
+import { MockHttp } from '@jaredwray/mockhttp';
+
+const mock = new MockHttp({ https: true });
+await mock.start();
+
+console.log(mock.isHttps); // true
+
+// Use Fastify's built-in inject() for testing (no TLS setup needed)
+const response = await mock.server.inject({ method: 'GET', url: '/get' });
+console.log(response.statusCode); // 200
+
+await mock.close();
+```
+
+> **Note:** Self-signed certificates are not trusted by default. When making real HTTPS requests (e.g. with `fetch`), set `NODE_TLS_REJECT_UNAUTHORIZED=0` in your test environment or use a custom HTTPS agent.
+
+## Custom Certificate Options
+
+You can customize the auto-generated certificate by passing `certificateOptions`:
+
+```javascript
+const mock = new MockHttp({
+  https: {
+    certificateOptions: {
+      commonName: 'my-test-server',
+      validityDays: 30,
+      keySize: 4096,
+      altNames: [
+        { type: 'dns', value: 'example.local' },
+        { type: 'dns', value: '*.example.local' },
+        { type: 'ip', value: '192.168.1.100' },
+      ],
+    },
+  },
+});
+
+await mock.start();
+// Make requests...
+await mock.close();
+```
+
+## Provide Your Own Certificate
+
+You can supply your own PEM-encoded certificate and key, either as strings or file paths:
+
+```javascript
+// Using PEM strings
+const mock = new MockHttp({
+  https: {
+    cert: '-----BEGIN CERTIFICATE-----\n...',
+    key: '-----BEGIN PRIVATE KEY-----\n...',
+  },
+});
+await mock.start();
+// Make requests...
+await mock.close();
+```
+
+```javascript
+// Using file paths
+const mock = new MockHttp({
+  https: {
+    cert: '/path/to/cert.pem',
+    key: '/path/to/key.pem',
+  },
+});
+await mock.start();
+// Make requests...
+await mock.close();
+```
+
+## Standalone Certificate Generation
+
+You can also generate certificates independently using the exported utility functions:
+
+```javascript
+import { generateCertificate, generateCertificateFiles } from '@jaredwray/mockhttp';
+
+// Generate in-memory PEM strings
+const { cert, key } = generateCertificate({
+  commonName: 'my-app',
+  validityDays: 90,
+});
+
+// Generate and write to disk
+const result = await generateCertificateFiles({
+  certPath: './certs/cert.pem',
+  keyPath: './certs/key.pem',
+  commonName: 'my-app',
+});
+```
+
+## HTTPS Options Reference
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `cert` | string | — | PEM-encoded certificate string or file path |
+| `key` | string | — | PEM-encoded private key string or file path |
+| `autoGenerate` | boolean | `true` | Auto-generate a self-signed certificate when cert/key are not provided |
+| `certificateOptions` | CertificateOptions | — | Options for the auto-generated certificate |
+
+### Certificate Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `commonName` | string | `'localhost'` | Certificate subject Common Name (CN) |
+| `altNames` | Array\<{ type, value }\> | `[dns:localhost, ip:127.0.0.1, ip:::1]` | Subject Alternative Names with type `'dns'` or `'ip'` |
+| `validityDays` | number | `365` | Certificate validity period in days |
+| `keySize` | number | `2048` | RSA key size in bits |
+
+# HTTP/2 Support
+
+MockHttp supports HTTP/2 in two modes:
+- **h2** — HTTP/2 over TLS (used by browsers), enabled with both `http2: true` and `https: true`
+- **h2c** — HTTP/2 cleartext (no TLS), enabled with just `http2: true`, useful for service-to-service testing
+
+## HTTP/2 over TLS (h2)
+
+```javascript
+import { MockHttp } from '@jaredwray/mockhttp';
+
+const mock = new MockHttp({ http2: true, https: true });
+await mock.start();
+
+console.log(mock.http2); // true
+console.log(mock.isHttps); // true
+
+const response = await mock.server.inject({ method: 'GET', url: '/get' });
+console.log(response.statusCode); // 200
+
+await mock.close();
+```
+
+By default, HTTP/1.1 clients can still connect via ALPN negotiation (`http1` defaults to `true`). To disable HTTP/1.1 fallback:
+
+```javascript
+const mock = new MockHttp({ http2: true, https: true, http1: false });
+await mock.start();
+```
+
+## HTTP/2 Cleartext (h2c)
+
+```javascript
+const mock = new MockHttp({ http2: true });
+await mock.start();
+
+console.log(mock.http2); // true
+
+await mock.close();
+```
+
+> **Note:** Browsers do not support h2c. This mode is useful for testing gRPC or service-to-service communication.
+
+## HTTP/2 via Environment Variable
+
+```bash
+HTTP2=true node your-app.js
 ```
 
 # Response Injection (Tap Feature)
@@ -467,6 +638,9 @@ new MockHttp(options?)
     - `anything?`: boolean - Enable anything routes (default: true)
     - `auth?`: boolean - Enable authentication routes (default: true)
     - `images?`: boolean - Enable image routes (default: true)
+  - `https?`: boolean | HttpsOptions - Enable HTTPS with auto-generated or custom certificates (default: undefined/disabled)
+  - `http2?`: boolean - Enable HTTP/2 support (default: false)
+  - `http1?`: boolean - Allow HTTP/1.1 fallback when using HTTP/2 with HTTPS (default: true)
   - `hookOptions?`: HookifiedOptions - Hookified options
 
 ### Properties
@@ -479,6 +653,10 @@ new MockHttp(options?)
 - `logging`: boolean - Get/set logging enabled state
 - `rateLimit`: RateLimitPluginOptions | undefined - Get/set rate limiting options
 - `httpBin`: HttpBinOptions - Get/set httpbin route options
+- `https`: HttpsOptions | undefined - Get/set HTTPS configuration
+- `isHttps`: boolean - Whether the server is running with HTTPS
+- `http2`: boolean - Get/set HTTP/2 support
+- `http1`: boolean - Get/set HTTP/1.1 fallback for HTTP/2 with HTTPS
 - `server`: FastifyInstance - Get/set the Fastify server instance
 - `taps`: TapManager - Get/set the TapManager instance
 

package/dist/index.d.ts

@@ -2,6 +2,61 @@ import { RateLimitPluginOptions } from '@fastify/rate-limit';
 import { FastifyRequest, FastifyInstance } from 'fastify';
 import { Hookified, HookifiedOptions } from 'hookified';
 
+type CertificateOptions = {
+    /**
+     * Common Name for the certificate subject. Defaults to 'localhost'.
+     */
+    commonName?: string;
+    /**
+     * Subject Alternative Names. Defaults to [dns:localhost, ip:127.0.0.1, ip:::1].
+     */
+    altNames?: Array<{
+        type: "dns";
+        value: string;
+    } | {
+        type: "ip";
+        value: string;
+    }>;
+    /**
+     * Number of days the certificate is valid. Defaults to 365.
+     */
+    validityDays?: number;
+    /**
+     * RSA key size in bits. Defaults to 2048.
+     */
+    keySize?: number;
+};
+type CertificateResult = {
+    /**
+     * PEM-encoded X.509 certificate.
+     */
+    cert: string;
+    /**
+     * PEM-encoded PKCS#8 private key.
+     */
+    key: string;
+};
+type CertificateFileOptions = CertificateOptions & {
+    /**
+     * File path to write the certificate PEM.
+     */
+    certPath: string;
+    /**
+     * File path to write the private key PEM.
+     */
+    keyPath: string;
+};
+/**
+ * Generate a self-signed certificate using only Node.js built-in crypto.
+ * Returns PEM-encoded certificate and private key strings.
+ */
+declare function generateCertificate(options?: CertificateOptions): CertificateResult;
+/**
+ * Generate a self-signed certificate and write PEM files to disk.
+ * Returns the same CertificateResult as generateCertificate().
+ */
+declare function generateCertificateFiles(options: CertificateFileOptions): Promise<CertificateResult>;
+
 /**
  * Configuration for the injected response
  */
@@ -134,6 +189,24 @@ type HttpBinOptions = {
     images?: boolean;
     dynamicData?: boolean;
 };
+type HttpsOptions = {
+    /**
+     * PEM-encoded certificate string, or file path to a certificate PEM file.
+     */
+    cert?: string;
+    /**
+     * PEM-encoded private key string, or file path to a private key PEM file.
+     */
+    key?: string;
+    /**
+     * If true, auto-generate a self-signed certificate. Defaults to true when no cert/key provided.
+     */
+    autoGenerate?: boolean;
+    /**
+     * Options for auto-generating a self-signed certificate. Only used when auto-generating.
+     */
+    certificateOptions?: CertificateOptions;
+};
 type MockHttpOptions = {
     /**
      * The port to listen on. If not provided, defaults to 3000 and detects the next available port if in use.
@@ -173,6 +246,23 @@ type MockHttpOptions = {
      * Whether to enable logging. Defaults to true.
      */
     logging?: boolean;
+    /**
+     * HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+     * or provide an object with cert/key strings/paths or auto-generation options.
+     */
+    https?: boolean | HttpsOptions;
+    /**
+     * Whether to enable HTTP/2 support. When used with `https`, enables h2 (HTTP/2 over TLS).
+     * When used without `https`, enables h2c (HTTP/2 cleartext).
+     * Defaults to false.
+     */
+    http2?: boolean;
+    /**
+     * Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS (ALPN negotiation).
+     * Only applies when both `http2` and `https` are enabled.
+     * Defaults to true.
+     */
+    http1?: boolean;
 };
 declare class MockHttp extends Hookified {
     private _port;
@@ -183,6 +273,10 @@ declare class MockHttp extends Hookified {
     private _logging;
     private _httpBin;
     private _rateLimit?;
+    private _http2;
+    private _http1;
+    private _https;
+    private _httpsCredentials;
     private _server;
     private _taps;
     constructor(options?: MockHttpOptions);
@@ -246,6 +340,40 @@ declare class MockHttp extends Hookified {
      * @default true
      */
     set logging(logging: boolean);
+    /**
+     * HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+     * or provide an HttpsOptions object with cert/key or auto-generation options.
+     */
+    get https(): HttpsOptions | undefined;
+    /**
+     * HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+     * or provide an HttpsOptions object with cert/key or auto-generation options.
+     */
+    set https(value: boolean | HttpsOptions | undefined);
+    /**
+     * Whether the server is running in HTTPS mode.
+     */
+    get isHttps(): boolean;
+    /**
+     * Whether HTTP/2 support is enabled.
+     * @default false
+     */
+    get http2(): boolean;
+    /**
+     * Whether HTTP/2 support is enabled.
+     * @default false
+     */
+    set http2(http2: boolean);
+    /**
+     * Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS.
+     * @default true
+     */
+    get http1(): boolean;
+    /**
+     * Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS.
+     * @default true
+     */
+    set http1(http1: boolean);
     /**
      * HTTP Bin options. Defaults to all enabled.
      */
@@ -353,8 +481,10 @@ declare class MockHttp extends Hookified {
      * @param fastifyInstance - the server instance to register the routes on.
      */
     registerDynamicDataRoutes(fastifyInstance?: FastifyInstance): Promise<void>;
+    private resolveHttpsCredentials;
+    private loadPemValue;
 }
 
 declare const start: () => Promise<MockHttp>;
 
-export { type InjectionMatcher, type InjectionResponse, type InjectionTap, MockHttp as default, MockHttp as mockhttp, start };
+export { type CertificateFileOptions, type CertificateOptions, type CertificateResult, type HttpsOptions, type InjectionMatcher, type InjectionResponse, type InjectionTap, MockHttp as default, generateCertificate, generateCertificateFiles, MockHttp as mockhttp, start };

package/dist/index.js

@@ -5,6 +5,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import process2 from "process";
 
 // src/mock-http.ts
+import * as fsPromises2 from "fs/promises";
 import path from "path";
 import fastifyCookie from "@fastify/cookie";
 import fastifyHelmet from "@fastify/helmet";
@@ -15,6 +16,307 @@ import { detect } from "detect-port";
 import Fastify from "fastify";
 import { Hookified } from "hookified";
 
+// src/certificate.ts
+import * as crypto from "crypto";
+import * as fsPromises from "fs/promises";
+function encodeLength(length) {
+  if (length < 128) {
+    return Buffer.from([
+      length
+    ]);
+  }
+  const bytes = [];
+  let temp = length;
+  while (temp > 0) {
+    bytes.unshift(temp & 255);
+    temp >>= 8;
+  }
+  return Buffer.from([
+    128 | bytes.length,
+    ...bytes
+  ]);
+}
+__name(encodeLength, "encodeLength");
+function encodeTlv(tag, value) {
+  return Buffer.concat([
+    Buffer.from([
+      tag
+    ]),
+    encodeLength(value.length),
+    value
+  ]);
+}
+__name(encodeTlv, "encodeTlv");
+function encodeSequence(...elements) {
+  const content = Buffer.concat(elements);
+  return encodeTlv(48, content);
+}
+__name(encodeSequence, "encodeSequence");
+function encodeSet(...elements) {
+  const content = Buffer.concat(elements);
+  return encodeTlv(49, content);
+}
+__name(encodeSet, "encodeSet");
+function encodeInteger(value) {
+  let buf;
+  if (typeof value === "number") {
+    if (value === 0) {
+      buf = Buffer.from([
+        0
+      ]);
+    } else {
+      const bytes = [];
+      let temp = value;
+      while (temp > 0) {
+        bytes.unshift(temp & 255);
+        temp >>= 8;
+      }
+      if (bytes[0] & 128) {
+        bytes.unshift(0);
+      }
+      buf = Buffer.from(bytes);
+    }
+  } else {
+    if (value.length > 0 && value[0] & 128) {
+      buf = Buffer.concat([
+        Buffer.from([
+          0
+        ]),
+        value
+      ]);
+    } else {
+      buf = value;
+    }
+  }
+  return encodeTlv(2, buf);
+}
+__name(encodeInteger, "encodeInteger");
+function encodeBitString(value) {
+  const content = Buffer.concat([
+    Buffer.from([
+      0
+    ]),
+    value
+  ]);
+  return encodeTlv(3, content);
+}
+__name(encodeBitString, "encodeBitString");
+function encodeOctetString(value) {
+  return encodeTlv(4, value);
+}
+__name(encodeOctetString, "encodeOctetString");
+function encodeOid(oid) {
+  const bytes = [];
+  bytes.push(40 * oid[0] + oid[1]);
+  for (let i = 2; i < oid.length; i++) {
+    let component = oid[i];
+    if (component < 128) {
+      bytes.push(component);
+    } else {
+      const encoded = [];
+      encoded.push(component & 127);
+      component >>= 7;
+      while (component > 0) {
+        encoded.push(component & 127 | 128);
+        component >>= 7;
+      }
+      encoded.reverse();
+      bytes.push(...encoded);
+    }
+  }
+  return encodeTlv(6, Buffer.from(bytes));
+}
+__name(encodeOid, "encodeOid");
+function encodeUtf8String(value) {
+  return encodeTlv(12, Buffer.from(value, "utf8"));
+}
+__name(encodeUtf8String, "encodeUtf8String");
+function encodeTime(date) {
+  const fullYear = date.getUTCFullYear();
+  const timePart = `${pad2(date.getUTCMonth() + 1)}${pad2(date.getUTCDate())}${pad2(date.getUTCHours())}${pad2(date.getUTCMinutes())}${pad2(date.getUTCSeconds())}Z`;
+  if (fullYear >= 2050) {
+    const str2 = `${fullYear}${timePart}`;
+    return encodeTlv(24, Buffer.from(str2, "ascii"));
+  }
+  const str = `${pad2(fullYear % 100)}${timePart}`;
+  return encodeTlv(23, Buffer.from(str, "ascii"));
+}
+__name(encodeTime, "encodeTime");
+function encodeContextSpecific(tag, value) {
+  return encodeTlv(160 | tag, value);
+}
+__name(encodeContextSpecific, "encodeContextSpecific");
+function pad2(n) {
+  return n.toString().padStart(2, "0");
+}
+__name(pad2, "pad2");
+var OID_SHA256_WITH_RSA = [
+  1,
+  2,
+  840,
+  113549,
+  1,
+  1,
+  11
+];
+var OID_COMMON_NAME = [
+  2,
+  5,
+  4,
+  3
+];
+var OID_SUBJECT_ALT_NAME = [
+  2,
+  5,
+  29,
+  17
+];
+function buildAlgorithmIdentifier() {
+  return encodeSequence(encodeOid(OID_SHA256_WITH_RSA), encodeTlv(5, Buffer.alloc(0)));
+}
+__name(buildAlgorithmIdentifier, "buildAlgorithmIdentifier");
+function buildName(cn) {
+  const rdn = encodeSet(encodeSequence(encodeOid(OID_COMMON_NAME), encodeUtf8String(cn)));
+  return encodeSequence(rdn);
+}
+__name(buildName, "buildName");
+function buildValidity(notBefore, notAfter) {
+  return encodeSequence(encodeTime(notBefore), encodeTime(notAfter));
+}
+__name(buildValidity, "buildValidity");
+function encodeIpAddress(ip) {
+  if (ip.includes(".")) {
+    const parts = ip.split(".").map(Number);
+    return Buffer.from(parts);
+  }
+  const expanded = expandIpv6(ip);
+  const buf = Buffer.alloc(16);
+  const groups = expanded.split(":");
+  for (let i = 0; i < 8; i++) {
+    const val = Number.parseInt(groups[i], 16);
+    buf.writeUInt16BE(val, i * 2);
+  }
+  return buf;
+}
+__name(encodeIpAddress, "encodeIpAddress");
+function expandIpv6(ip) {
+  if (ip.includes("::")) {
+    const [left, right] = ip.split("::");
+    const leftGroups = left ? left.split(":") : [];
+    const rightGroups = right ? right.split(":") : [];
+    const missing = 8 - leftGroups.length - rightGroups.length;
+    const middle = Array.from({
+      length: missing
+    }).fill("0000");
+    const allGroups = [
+      ...leftGroups,
+      ...middle,
+      ...rightGroups
+    ];
+    return allGroups.map((g) => g.padStart(4, "0")).join(":");
+  }
+  return ip.split(":").map((g) => g.padStart(4, "0")).join(":");
+}
+__name(expandIpv6, "expandIpv6");
+function buildSubjectAltNameExtension(altNames) {
+  const names = [];
+  for (const alt of altNames) {
+    if (alt.type === "dns") {
+      names.push(encodeTlv(130, Buffer.from(alt.value, "ascii")));
+    } else {
+      names.push(encodeTlv(135, encodeIpAddress(alt.value)));
+    }
+  }
+  const sanValue = encodeSequence(...names);
+  return encodeSequence(encodeOid(OID_SUBJECT_ALT_NAME), encodeOctetString(sanValue));
+}
+__name(buildSubjectAltNameExtension, "buildSubjectAltNameExtension");
+function buildExtensions(altNames) {
+  const extensions = encodeSequence(buildSubjectAltNameExtension(altNames));
+  return encodeContextSpecific(3, extensions);
+}
+__name(buildExtensions, "buildExtensions");
+function buildTbsCertificate(serialNumber, issuerCn, notBefore, notAfter, subjectCn, publicKeyDer, altNames) {
+  const version = encodeContextSpecific(0, encodeInteger(2));
+  const serial = encodeInteger(serialNumber);
+  const signatureAlgorithm = buildAlgorithmIdentifier();
+  const issuer = buildName(issuerCn);
+  const validity = buildValidity(notBefore, notAfter);
+  const subject = buildName(subjectCn);
+  const extensions = buildExtensions(altNames);
+  return encodeSequence(version, serial, signatureAlgorithm, issuer, validity, subject, publicKeyDer, extensions);
+}
+__name(buildTbsCertificate, "buildTbsCertificate");
+function derToPem(der, label) {
+  const base64 = der.toString("base64");
+  const lines = [];
+  for (let i = 0; i < base64.length; i += 64) {
+    lines.push(base64.slice(i, i + 64));
+  }
+  return `-----BEGIN ${label}-----
+${lines.join("\n")}
+-----END ${label}-----
+`;
+}
+__name(derToPem, "derToPem");
+function generateCertificate(options) {
+  const commonName = options?.commonName ?? "localhost";
+  const validityDays = options?.validityDays ?? 365;
+  const keySize = options?.keySize ?? 2048;
+  const altNames = options?.altNames ?? [
+    {
+      type: "dns",
+      value: "localhost"
+    },
+    {
+      type: "ip",
+      value: "127.0.0.1"
+    },
+    {
+      type: "ip",
+      value: "::1"
+    }
+  ];
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
+    modulusLength: keySize,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "der"
+    },
+    privateKeyEncoding: {
+      type: "pkcs8",
+      format: "pem"
+    }
+  });
+  const notBefore = /* @__PURE__ */ new Date();
+  const notAfter = /* @__PURE__ */ new Date();
+  notAfter.setDate(notAfter.getDate() + validityDays);
+  const serialBytes = crypto.randomBytes(16);
+  serialBytes[0] &= 127;
+  let start2 = 0;
+  while (start2 < serialBytes.length - 1 && serialBytes[start2] === 0) {
+    start2++;
+  }
+  const serialNumber = serialBytes.subarray(start2);
+  const tbsCertificate = buildTbsCertificate(serialNumber, commonName, notBefore, notAfter, commonName, publicKey, altNames);
+  const signer = crypto.createSign("SHA256");
+  signer.update(tbsCertificate);
+  const signature = signer.sign(privateKey);
+  const certificate = encodeSequence(tbsCertificate, buildAlgorithmIdentifier(), encodeBitString(signature));
+  return {
+    cert: derToPem(certificate, "CERTIFICATE"),
+    key: privateKey
+  };
+}
+__name(generateCertificate, "generateCertificate");
+async function generateCertificateFiles(options) {
+  const result = generateCertificate(options);
+  await fsPromises.writeFile(options.certPath, result.cert, "utf8");
+  await fsPromises.writeFile(options.keyPath, result.key, "utf8");
+  return result;
+}
+__name(generateCertificateFiles, "generateCertificateFiles");
+
 // src/fastify-config.ts
 function getFastifyConfig(logging = true) {
   return {
@@ -328,8 +630,8 @@ var bearerAuthRoute = /* @__PURE__ */ __name((fastify) => {
 }, "bearerAuthRoute");
 
 // src/routes/auth/digest.ts
-import crypto from "crypto";
-var makeNonce = /* @__PURE__ */ __name(() => crypto.randomBytes(16).toString("hex"), "makeNonce");
+import crypto2 from "crypto";
+var makeNonce = /* @__PURE__ */ __name(() => crypto2.randomBytes(16).toString("hex"), "makeNonce");
 var algorithms = /* @__PURE__ */ new Set([
   "MD5",
   "md5",
@@ -354,7 +656,7 @@ var hashAlg = /* @__PURE__ */ __name((alg) => {
   }
   return "md5";
 }, "hashAlg");
-var h = /* @__PURE__ */ __name((algo, data) => crypto.createHash(algo).update(data).digest("hex"), "h");
+var h = /* @__PURE__ */ __name((algo, data) => crypto2.createHash(algo).update(data).digest("hex"), "h");
 var parseDigest = /* @__PURE__ */ __name((header) => {
   if (!header) {
     return void 0;
@@ -771,7 +1073,7 @@ var base64Route = /* @__PURE__ */ __name((fastify) => {
 }, "base64Route");
 
 // src/routes/dynamic-data/bytes.ts
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 var bytesSchema = {
   description: "Returns n random bytes generated with given seed",
   tags: [
@@ -853,7 +1155,7 @@ var bytesRoute = /* @__PURE__ */ __name((fastify) => {
       }
       bytes = generateSeededBytes(limitedN, seed);
     } else {
-      bytes = randomBytes(limitedN);
+      bytes = randomBytes2(limitedN);
     }
     return reply.header("Content-Type", "application/octet-stream").header("Content-Length", bytes.length).send(bytes);
   });
@@ -1375,7 +1677,7 @@ var streamRoute = /* @__PURE__ */ __name((fastify) => {
 }, "streamRoute");
 
 // src/routes/dynamic-data/stream-bytes.ts
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 var streamBytesSchema = {
   description: "Streams n random bytes generated with given seed, in chunks of chunk_size per packet",
   tags: [
@@ -1468,7 +1770,7 @@ var streamBytesRoute = /* @__PURE__ */ __name((fastify) => {
       }
       allBytes = generateSeededBytes2(limitedN, seed);
     } else {
-      allBytes = randomBytes2(limitedN);
+      allBytes = randomBytes3(limitedN);
     }
     reply.raw.writeHead(200, {
       "Content-Type": "application/octet-stream",
@@ -3530,7 +3832,7 @@ import { fastifySwaggerUi } from "@fastify/swagger-ui";
 // package.json
 var package_default = {
   name: "@jaredwray/mockhttp",
-  version: "1.3.0",
+  version: "1.5.0",
   description: "Mock Http - Easy way to mock http with httpbin replacement",
   type: "module",
   main: "dist/index.js",
@@ -3581,29 +3883,29 @@ var package_default = {
   },
   homepage: "https://github.com/jaredwray/mockhttp#readme",
   devDependencies: {
-    "@biomejs/biome": "^2.3.11",
-    "@swc/core": "^1.15.8",
+    "@biomejs/biome": "^2.4.7",
+    "@swc/core": "^1.15.18",
     "@types/html-escaper": "^3.0.4",
-    "@vitest/coverage-v8": "^4.0.16",
-    rimraf: "^6.1.2",
+    "@vitest/coverage-v8": "^4.1.0",
+    rimraf: "^6.1.3",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
     typescript: "^5.9.3",
-    vitest: "^4.0.16"
+    vitest: "^4.1.0"
   },
   dependencies: {
     "@fastify/cookie": "^11.0.2",
     "@fastify/helmet": "^13.0.2",
     "@fastify/rate-limit": "^10.3.0",
     "@fastify/static": "^9.0.0",
-    "@fastify/swagger": "^9.6.1",
-    "@fastify/swagger-ui": "^5.2.4",
-    "@scalar/api-reference": "^1.43.1",
+    "@fastify/swagger": "^9.7.0",
+    "@fastify/swagger-ui": "^5.2.5",
+    "@scalar/api-reference": "^1.48.7",
     "detect-port": "^2.1.0",
-    fastify: "^5.6.2",
-    hookified: "^1.15.0",
+    fastify: "^5.8.2",
+    hookified: "^2.1.0",
     "html-escaper": "^3.0.3",
-    pino: "^10.1.1",
+    pino: "^10.3.1",
     "pino-pretty": "^13.1.3"
   },
   files: [
@@ -3822,6 +4124,10 @@ var MockHttp = class extends Hookified {
       "::1"
     ]
   };
+  _http2 = false;
+  _http1 = true;
+  _https;
+  _httpsCredentials;
   _server = Fastify();
   _taps = new TapManager();
   constructor(options) {
@@ -3851,6 +4157,23 @@ var MockHttp = class extends Hookified {
     if (options?.logging !== void 0) {
       this._logging = options.logging;
     }
+    if (options?.http2 !== void 0) {
+      this._http2 = options.http2;
+    }
+    if (options?.http1 !== void 0) {
+      this._http1 = options.http1;
+    }
+    if (options?.https !== void 0) {
+      if (options.https === true) {
+        this._https = {
+          autoGenerate: true
+        };
+      } else if (options.https === false) {
+        this._https = void 0;
+      } else {
+        this._https = options.https;
+      }
+    }
   }
   /**
   * The port to listen on. If not provided, defaults to 3000 and detects the next available port if in use.
@@ -3937,6 +4260,62 @@ var MockHttp = class extends Hookified {
     this._logging = logging;
   }
   /**
+  * HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+  * or provide an HttpsOptions object with cert/key or auto-generation options.
+  */
+  get https() {
+    return this._https;
+  }
+  /**
+  * HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+  * or provide an HttpsOptions object with cert/key or auto-generation options.
+  */
+  set https(value) {
+    if (value === true) {
+      this._https = {
+        autoGenerate: true
+      };
+    } else if (value === false || value === void 0) {
+      this._https = void 0;
+    } else {
+      this._https = value;
+    }
+  }
+  /**
+  * Whether the server is running in HTTPS mode.
+  */
+  get isHttps() {
+    return this._httpsCredentials !== void 0;
+  }
+  /**
+  * Whether HTTP/2 support is enabled.
+  * @default false
+  */
+  get http2() {
+    return this._http2;
+  }
+  /**
+  * Whether HTTP/2 support is enabled.
+  * @default false
+  */
+  set http2(http2) {
+    this._http2 = http2;
+  }
+  /**
+  * Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS.
+  * @default true
+  */
+  get http1() {
+    return this._http1;
+  }
+  /**
+  * Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS.
+  * @default true
+  */
+  set http1(http1) {
+    this._http1 = http1;
+  }
+  /**
   * HTTP Bin options. Defaults to all enabled.
   */
   get httpBin() {
@@ -3994,11 +4373,31 @@ var MockHttp = class extends Hookified {
   * Start the Fastify server. If the server is already running, it will be closed and restarted.
   */
   async start() {
+    this._httpsCredentials = void 0;
+    if (this._https) {
+      this._httpsCredentials = await this.resolveHttpsCredentials(this._https);
+    }
     try {
       if (this._server) {
         await this._server.close();
       }
-      this._server = Fastify(getFastifyConfig(this._logging));
+      const fastifyOptions = {
+        ...getFastifyConfig(this._logging)
+      };
+      if (this._http2) {
+        fastifyOptions.http2 = true;
+      }
+      if (this._httpsCredentials) {
+        const httpsOptions = {
+          key: this._httpsCredentials.key,
+          cert: this._httpsCredentials.cert
+        };
+        if (this._http2) {
+          httpsOptions.allowHTTP1 = this._http1;
+        }
+        fastifyOptions.https = httpsOptions;
+      }
+      this._server = Fastify(fastifyOptions);
       this._server.addHook("onRequest", async (request, reply) => {
         const matchedTap = this._taps.matchRequest(request);
         if (matchedTap) {
@@ -4248,6 +4647,33 @@ var MockHttp = class extends Hookified {
     await fastify.register(dripRoute);
     await fastify.register(linksRoute);
   }
+  async resolveHttpsCredentials(options) {
+    if (options.cert && options.key) {
+      const cert = await this.loadPemValue(options.cert);
+      const key = await this.loadPemValue(options.key);
+      return {
+        cert,
+        key
+      };
+    }
+    if ((options.cert || options.key) && options.autoGenerate !== true) {
+      throw new Error("HTTPS options must include both 'cert' and 'key'. Only one was provided.");
+    }
+    if (options.autoGenerate !== false) {
+      const result = generateCertificate(options.certificateOptions);
+      return {
+        cert: result.cert,
+        key: result.key
+      };
+    }
+    throw new Error("HTTPS is enabled but no certificate was provided and autoGenerate is false.");
+  }
+  async loadPemValue(value) {
+    if (value.startsWith("-----")) {
+      return value;
+    }
+    return fsPromises2.readFile(value, "utf8");
+  }
 };
 
 // src/index.ts
@@ -4262,6 +4688,9 @@ var start = /* @__PURE__ */ __name(async () => {
   if (process2.env.LOGGING === "false") {
     mockHttp.logging = false;
   }
+  if (process2.env.HTTP2 === "true") {
+    mockHttp.http2 = true;
+  }
   await mockHttp.start();
   return mockHttp;
 }, "start");
@@ -4270,6 +4699,8 @@ if (import.meta.url === `file://${process2.argv[1]}`) {
 }
 export {
   MockHttp as default,
+  generateCertificate,
+  generateCertificateFiles,
   MockHttp as mockhttp,
   start
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jaredwray/mockhttp",
-	"version": "1.3.0",
+	"version": "1.5.0",
 	"description": "Mock Http - Easy way to mock http with httpbin replacement",
 	"type": "module",
 	"main": "dist/index.js",
@@ -51,29 +51,29 @@
 	},
 	"homepage": "https://github.com/jaredwray/mockhttp#readme",
 	"devDependencies": {
-		"@biomejs/biome": "^2.3.11",
-		"@swc/core": "^1.15.8",
+		"@biomejs/biome": "^2.4.7",
+		"@swc/core": "^1.15.18",
 		"@types/html-escaper": "^3.0.4",
-		"@vitest/coverage-v8": "^4.0.16",
-		"rimraf": "^6.1.2",
+		"@vitest/coverage-v8": "^4.1.0",
+		"rimraf": "^6.1.3",
 		"tsup": "^8.5.1",
 		"tsx": "^4.21.0",
 		"typescript": "^5.9.3",
-		"vitest": "^4.0.16"
+		"vitest": "^4.1.0"
 	},
 	"dependencies": {
 		"@fastify/cookie": "^11.0.2",
 		"@fastify/helmet": "^13.0.2",
 		"@fastify/rate-limit": "^10.3.0",
 		"@fastify/static": "^9.0.0",
-		"@fastify/swagger": "^9.6.1",
-		"@fastify/swagger-ui": "^5.2.4",
-		"@scalar/api-reference": "^1.43.1",
+		"@fastify/swagger": "^9.7.0",
+		"@fastify/swagger-ui": "^5.2.5",
+		"@scalar/api-reference": "^1.48.7",
 		"detect-port": "^2.1.0",
-		"fastify": "^5.6.2",
-		"hookified": "^1.15.0",
+		"fastify": "^5.8.2",
+		"hookified": "^2.1.0",
 		"html-escaper": "^3.0.3",
-		"pino": "^10.1.1",
+		"pino": "^10.3.1",
 		"pino-pretty": "^13.1.3"
 	},
 	"files": [