@jaredwray/mockhttp 1.2.0 → 1.4.0

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;
@@ -712,6 +1014,808 @@ var postCookieRoute = /* @__PURE__ */ __name((fastify) => {
   });
 }, "postCookieRoute");
 
+// src/routes/dynamic-data/base64.ts
+var base64Schema = {
+  description: "Decodes base64url-encoded string",
+  tags: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      value: {
+        type: "string",
+        description: "Base64 encoded value to decode"
+      }
+    },
+    required: [
+      "value"
+    ]
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Decoded value"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+function isValidBase64(str) {
+  const base64Regex = /^[A-Za-z0-9+/\-_]*={0,2}$/;
+  if (!base64Regex.test(str)) {
+    return false;
+  }
+  const strippedLength = str.replace(/=+$/, "").length;
+  return strippedLength % 4 !== 1;
+}
+__name(isValidBase64, "isValidBase64");
+var base64Route = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/base64/:value", {
+    schema: base64Schema
+  }, async (request, reply) => {
+    const { value } = request.params;
+    if (!isValidBase64(value)) {
+      return reply.code(400).send({
+        error: "Incorrect Base64 data"
+      });
+    }
+    const normalizedValue = value.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = Buffer.from(normalizedValue, "base64").toString("utf-8");
+    return reply.header("Content-Type", "text/html; charset=utf-8").send(decoded);
+  });
+}, "base64Route");
+
+// src/routes/dynamic-data/bytes.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var bytesSchema = {
+  description: "Returns n random bytes generated with given seed",
+  tags: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      n: {
+        type: "string",
+        description: "Number of bytes to generate"
+      }
+    },
+    required: [
+      "n"
+    ]
+  },
+  querystring: {
+    type: "object",
+    properties: {
+      seed: {
+        type: "string",
+        description: "Seed for random number generation"
+      }
+    }
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Random binary data"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+function seededRandom(seed) {
+  let state = seed;
+  return () => {
+    state = state * 1103515245 + 12345 & 2147483647;
+    return state / 2147483647;
+  };
+}
+__name(seededRandom, "seededRandom");
+function generateSeededBytes(n, seed) {
+  const random = seededRandom(seed);
+  const bytes = Buffer.alloc(n);
+  for (let i = 0; i < n; i++) {
+    bytes[i] = Math.floor(random() * 256);
+  }
+  return bytes;
+}
+__name(generateSeededBytes, "generateSeededBytes");
+var MAX_BYTES = 100 * 1024;
+var bytesRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/bytes/:n", {
+    schema: bytesSchema
+  }, async (request, reply) => {
+    const n = Number.parseInt(request.params.n, 10);
+    if (Number.isNaN(n) || n < 0) {
+      return reply.code(400).send({
+        error: "n must be a non-negative integer"
+      });
+    }
+    const limitedN = Math.min(n, MAX_BYTES);
+    const seedParam = request.query.seed;
+    let bytes;
+    if (seedParam !== void 0) {
+      const seed = Number.parseInt(seedParam, 10);
+      if (Number.isNaN(seed)) {
+        return reply.code(400).send({
+          error: "seed must be an integer"
+        });
+      }
+      bytes = generateSeededBytes(limitedN, seed);
+    } else {
+      bytes = randomBytes2(limitedN);
+    }
+    return reply.header("Content-Type", "application/octet-stream").header("Content-Length", bytes.length).send(bytes);
+  });
+}, "bytesRoute");
+
+// src/routes/dynamic-data/delay.ts
+var delaySchema = {
+  description: "Returns a delayed response (max of 10 seconds)",
+  tags: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      delay: {
+        type: "string",
+        description: "Delay in seconds (max 10)"
+      }
+    },
+    required: [
+      "delay"
+    ]
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: true
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        args: {
+          type: "object"
+        },
+        data: {
+          type: "string"
+        },
+        files: {
+          type: "object"
+        },
+        form: {
+          type: "object"
+        },
+        headers: {
+          type: "object"
+        },
+        origin: {
+          type: "string"
+        },
+        url: {
+          type: "string"
+        }
+      }
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+var MAX_DELAY = 10;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+var delayRoute = /* @__PURE__ */ __name((fastify) => {
+  const handler = /* @__PURE__ */ __name(async (request, reply) => {
+    const delay = Number.parseFloat(request.params.delay);
+    if (Number.isNaN(delay) || delay < 0) {
+      return reply.code(400).send({
+        error: "delay must be a non-negative number"
+      });
+    }
+    const actualDelay = Math.min(delay, MAX_DELAY);
+    await sleep(actualDelay * 1e3);
+    const { protocol } = request;
+    const host = request.headers.host || "localhost";
+    return {
+      /* v8 ignore next -- @preserve */
+      args: request.query || {},
+      data: "",
+      files: {},
+      form: {},
+      headers: request.headers,
+      origin: request.ip,
+      url: `${protocol}://${host}${request.url}`
+    };
+  }, "handler");
+  fastify.get("/delay/:delay", {
+    schema: delaySchema
+  }, handler);
+  fastify.post("/delay/:delay", {
+    schema: delaySchema
+  }, handler);
+  fastify.put("/delay/:delay", {
+    schema: delaySchema
+  }, handler);
+  fastify.patch("/delay/:delay", {
+    schema: delaySchema
+  }, handler);
+  fastify.delete("/delay/:delay", {
+    schema: delaySchema
+  }, handler);
+}, "delayRoute");
+
+// src/routes/dynamic-data/drip.ts
+var dripSchema = {
+  description: "Drips data over a duration after an optional initial delay, then (optionally) returns with the given status code",
+  tags: [
+    "Dynamic Data"
+  ],
+  querystring: {
+    type: "object",
+    properties: {
+      duration: {
+        type: "string",
+        description: "Duration in seconds over which to drip the data (default: 2)"
+      },
+      numbytes: {
+        type: "string",
+        description: "Number of bytes to send (default: 10)"
+      },
+      code: {
+        type: "string",
+        description: "HTTP status code to return (default: 200)"
+      },
+      delay: {
+        type: "string",
+        description: "Initial delay in seconds before starting (default: 2)"
+      }
+    }
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Dripped data"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep2, "sleep");
+var DEFAULT_DURATION = 2;
+var DEFAULT_NUMBYTES = 10;
+var DEFAULT_CODE = 200;
+var DEFAULT_DELAY = 2;
+var MAX_DURATION = 10;
+var MAX_DELAY2 = 10;
+var MAX_BYTES2 = 10 * 1024 * 1024;
+var dripRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/drip", {
+    schema: dripSchema
+  }, async (request, reply) => {
+    const duration = request.query.duration ? Number.parseFloat(request.query.duration) : DEFAULT_DURATION;
+    const numbytes = request.query.numbytes ? Number.parseInt(request.query.numbytes, 10) : DEFAULT_NUMBYTES;
+    const code = request.query.code ? Number.parseInt(request.query.code, 10) : DEFAULT_CODE;
+    const delay = request.query.delay ? Number.parseFloat(request.query.delay) : DEFAULT_DELAY;
+    if (Number.isNaN(duration) || duration < 0) {
+      return reply.code(400).send({
+        error: "duration must be a non-negative number"
+      });
+    }
+    if (Number.isNaN(numbytes) || numbytes < 0) {
+      return reply.code(400).send({
+        error: "numbytes must be a non-negative integer"
+      });
+    }
+    if (Number.isNaN(code) || code < 100 || code > 599) {
+      return reply.code(400).send({
+        error: "code must be a valid HTTP status code"
+      });
+    }
+    if (Number.isNaN(delay) || delay < 0) {
+      return reply.code(400).send({
+        error: "delay must be a non-negative number"
+      });
+    }
+    const actualDuration = Math.min(duration, MAX_DURATION);
+    const actualDelay = Math.min(delay, MAX_DELAY2);
+    const actualBytes = Math.min(numbytes, MAX_BYTES2);
+    if (actualDelay > 0) {
+      await sleep2(actualDelay * 1e3);
+    }
+    reply.raw.writeHead(code, {
+      "Content-Type": "application/octet-stream",
+      "Content-Length": actualBytes.toString()
+    });
+    if (actualBytes === 0) {
+      reply.raw.end();
+      return;
+    }
+    const intervalMs = actualBytes > 1 ? actualDuration * 1e3 / (actualBytes - 1) : 0;
+    const byte = Buffer.from("*");
+    for (let i = 0; i < actualBytes; i++) {
+      reply.raw.write(byte);
+      if (i < actualBytes - 1 && intervalMs > 0) {
+        await sleep2(intervalMs);
+      }
+    }
+    reply.raw.end();
+  });
+}, "dripRoute");
+
+// src/routes/dynamic-data/links.ts
+var linksSchema = {
+  description: "Generate a page containing n links to other pages which do the same",
+  tags: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      n: {
+        type: "string",
+        description: "Number of links to generate"
+      },
+      offset: {
+        type: "string",
+        description: "Starting offset for pagination (default: 0)"
+      }
+    },
+    required: [
+      "n"
+    ]
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "HTML page with links"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+var MAX_LINKS = 200;
+var linksRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/links/:n/:offset?", {
+    schema: linksSchema
+  }, async (request, reply) => {
+    const n = Number.parseInt(request.params.n, 10);
+    const offset = request.params.offset ? Number.parseInt(request.params.offset, 10) : 0;
+    if (Number.isNaN(n) || n < 0) {
+      return reply.code(400).send({
+        error: "n must be a non-negative integer"
+      });
+    }
+    if (Number.isNaN(offset) || offset < 0) {
+      return reply.code(400).send({
+        error: "offset must be a non-negative integer"
+      });
+    }
+    const limitedN = Math.min(n, MAX_LINKS);
+    const links = [];
+    for (let i = 0; i < limitedN; i++) {
+      if (i === offset) {
+        links.push(`${i} `);
+      } else {
+        links.push(`<a href="/links/${limitedN}/${i}">${i}</a> `);
+      }
+    }
+    const html = `<html>
+<head>
+<title>Links</title>
+</head>
+<body>
+${links.join("")}
+</body>
+</html>`;
+    return reply.header("Content-Type", "text/html; charset=utf-8").send(html);
+  });
+}, "linksRoute");
+
+// src/routes/dynamic-data/range.ts
+var rangeSchema = {
+  description: "Streams n random bytes generated, and supports HTTP Range requests",
+  tags: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      numbytes: {
+        type: "string",
+        description: "Number of bytes available"
+      }
+    },
+    required: [
+      "numbytes"
+    ]
+  },
+  querystring: {
+    type: "object",
+    properties: {
+      duration: {
+        type: "string",
+        description: "Delay before sending response in seconds"
+      }
+    }
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Binary data"
+    },
+    206: {
+      type: "string",
+      description: "Partial binary data"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    },
+    416: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+var MAX_BYTES3 = 100 * 1024;
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep3, "sleep");
+function generateBytes(n) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz";
+  const bytes = Buffer.alloc(n);
+  for (let i = 0; i < n; i++) {
+    bytes[i] = alphabet.charCodeAt(i % alphabet.length);
+  }
+  return bytes;
+}
+__name(generateBytes, "generateBytes");
+function parseRangeHeader(rangeHeader, totalSize) {
+  const match = rangeHeader.match(/^bytes=(.+)$/);
+  if (!match) return null;
+  const ranges = [];
+  const parts = match[1].split(",");
+  for (const part of parts) {
+    const trimmedPart = part.trim();
+    if (trimmedPart.startsWith("-")) {
+      const suffix = Number.parseInt(trimmedPart.slice(1), 10);
+      if (Number.isNaN(suffix)) return null;
+      ranges.push({
+        start: Math.max(0, totalSize - suffix),
+        end: totalSize - 1
+      });
+    } else if (trimmedPart.endsWith("-")) {
+      const start2 = Number.parseInt(trimmedPart.slice(0, -1), 10);
+      if (Number.isNaN(start2)) return null;
+      ranges.push({
+        start: start2,
+        end: totalSize - 1
+      });
+    } else {
+      const [startStr, endStr] = trimmedPart.split("-");
+      const start2 = Number.parseInt(startStr, 10);
+      const end = Number.parseInt(endStr, 10);
+      if (Number.isNaN(start2) || Number.isNaN(end)) return null;
+      ranges.push({
+        start: start2,
+        end: Math.min(end, totalSize - 1)
+      });
+    }
+  }
+  for (const range of ranges) {
+    if (range.start > range.end || range.start >= totalSize) {
+      return null;
+    }
+  }
+  return ranges;
+}
+__name(parseRangeHeader, "parseRangeHeader");
+var rangeRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/range/:numbytes", {
+    schema: rangeSchema
+  }, async (request, reply) => {
+    const numbytes = Number.parseInt(request.params.numbytes, 10);
+    if (Number.isNaN(numbytes) || numbytes < 0) {
+      return reply.code(400).send({
+        error: "numbytes must be a non-negative integer"
+      });
+    }
+    const limitedBytes = Math.min(numbytes, MAX_BYTES3);
+    if (request.query.duration) {
+      const duration = Number.parseFloat(request.query.duration);
+      if (!Number.isNaN(duration) && duration > 0) {
+        await sleep3(Math.min(duration, 10) * 1e3);
+      }
+    }
+    const allBytes = generateBytes(limitedBytes);
+    const rangeHeader = request.headers.range;
+    if (!rangeHeader) {
+      return reply.header("Content-Type", "application/octet-stream").header("Content-Length", allBytes.length).header("Accept-Ranges", "bytes").send(allBytes);
+    }
+    const ranges = parseRangeHeader(rangeHeader, limitedBytes);
+    if (!ranges || ranges.length === 0) {
+      return reply.code(416).header("Content-Range", `bytes */${limitedBytes}`).send({
+        error: "Range Not Satisfiable"
+      });
+    }
+    if (ranges.length === 1) {
+      const range = ranges[0];
+      const chunk = allBytes.subarray(range.start, range.end + 1);
+      return reply.code(206).header("Content-Type", "application/octet-stream").header("Content-Length", chunk.length).header("Accept-Ranges", "bytes").header("Content-Range", `bytes ${range.start}-${range.end}/${limitedBytes}`).send(chunk);
+    }
+    const boundary = "3d6b6a416f9b5";
+    const parts = [];
+    for (const range of ranges) {
+      const chunk = allBytes.subarray(range.start, range.end + 1);
+      const header = `\r
+--${boundary}\r
+Content-Type: application/octet-stream\r
+Content-Range: bytes ${range.start}-${range.end}/${limitedBytes}\r
+\r
+`;
+      parts.push(Buffer.from(header));
+      parts.push(chunk);
+    }
+    parts.push(Buffer.from(`\r
+--${boundary}--\r
+`));
+    const multipartBody = Buffer.concat(parts);
+    return reply.code(206).header("Content-Type", `multipart/byteranges; boundary=${boundary}`).header("Content-Length", multipartBody.length).send(multipartBody);
+  });
+}, "rangeRoute");
+
+// src/routes/dynamic-data/stream.ts
+var streamSchema = {
+  description: "Stream n JSON responses",
+  tags: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      n: {
+        type: "string",
+        description: "Number of JSON responses to stream (max 100)"
+      }
+    },
+    required: [
+      "n"
+    ]
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Newline-delimited JSON responses"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+var MAX_LINES = 100;
+var streamRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/stream/:n", {
+    schema: streamSchema
+  }, async (request, reply) => {
+    const n = Number.parseInt(request.params.n, 10);
+    if (Number.isNaN(n) || n < 0) {
+      return reply.code(400).send({
+        error: "n must be a non-negative integer"
+      });
+    }
+    const lines = Math.min(n, MAX_LINES);
+    const { protocol } = request;
+    const host = request.headers.host || "localhost";
+    reply.raw.writeHead(200, {
+      "Content-Type": "application/json",
+      "Transfer-Encoding": "chunked"
+    });
+    for (let i = 0; i < lines; i++) {
+      const data = {
+        id: i,
+        /* v8 ignore next -- @preserve */
+        args: request.query || {},
+        headers: request.headers,
+        origin: request.ip,
+        url: `${protocol}://${host}${request.url}`
+      };
+      reply.raw.write(`${JSON.stringify(data)}
+`);
+    }
+    reply.raw.end();
+  });
+}, "streamRoute");
+
+// src/routes/dynamic-data/stream-bytes.ts
+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: [
+    "Dynamic Data"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      n: {
+        type: "string",
+        description: "Number of bytes to stream"
+      }
+    },
+    required: [
+      "n"
+    ]
+  },
+  querystring: {
+    type: "object",
+    properties: {
+      seed: {
+        type: "string",
+        description: "Seed for random number generation"
+      },
+      chunk_size: {
+        type: "string",
+        description: "Size of each chunk (default: 10240)"
+      }
+    }
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Streamed random binary data"
+    },
+    400: {
+      type: "object",
+      properties: {
+        error: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+function seededRandom2(seed) {
+  let state = seed;
+  return () => {
+    state = state * 1103515245 + 12345 & 2147483647;
+    return state / 2147483647;
+  };
+}
+__name(seededRandom2, "seededRandom");
+function generateSeededBytes2(n, seed) {
+  const random = seededRandom2(seed);
+  const bytes = Buffer.alloc(n);
+  for (let i = 0; i < n; i++) {
+    bytes[i] = Math.floor(random() * 256);
+  }
+  return bytes;
+}
+__name(generateSeededBytes2, "generateSeededBytes");
+var MAX_BYTES4 = 100 * 1024;
+var DEFAULT_CHUNK_SIZE = 10240;
+var streamBytesRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/stream-bytes/:n", {
+    schema: streamBytesSchema
+  }, async (request, reply) => {
+    const n = Number.parseInt(request.params.n, 10);
+    if (Number.isNaN(n) || n < 0) {
+      return reply.code(400).send({
+        error: "n must be a non-negative integer"
+      });
+    }
+    const limitedN = Math.min(n, MAX_BYTES4);
+    const chunkSize = request.query.chunk_size ? Number.parseInt(request.query.chunk_size, 10) : DEFAULT_CHUNK_SIZE;
+    if (Number.isNaN(chunkSize) || chunkSize <= 0) {
+      return reply.code(400).send({
+        error: "chunk_size must be a positive integer"
+      });
+    }
+    const seedParam = request.query.seed;
+    let allBytes;
+    if (seedParam !== void 0) {
+      const seed = Number.parseInt(seedParam, 10);
+      if (Number.isNaN(seed)) {
+        return reply.code(400).send({
+          error: "seed must be an integer"
+        });
+      }
+      allBytes = generateSeededBytes2(limitedN, seed);
+    } else {
+      allBytes = randomBytes3(limitedN);
+    }
+    reply.raw.writeHead(200, {
+      "Content-Type": "application/octet-stream",
+      "Transfer-Encoding": "chunked"
+    });
+    let offset = 0;
+    while (offset < allBytes.length) {
+      const chunk = allBytes.subarray(offset, offset + chunkSize);
+      reply.raw.write(chunk);
+      offset += chunkSize;
+    }
+    reply.raw.end();
+  });
+}, "streamBytesRoute");
+
+// src/routes/dynamic-data/uuid.ts
+import { randomUUID } from "crypto";
+var uuidSchema = {
+  description: "Return a UUID4",
+  tags: [
+    "Dynamic Data"
+  ],
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        uuid: {
+          type: "string",
+          format: "uuid"
+        }
+      },
+      required: [
+        "uuid"
+      ]
+    }
+  }
+};
+var uuidRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/uuid", {
+    schema: uuidSchema
+  }, async () => ({
+    uuid: randomUUID()
+  }));
+}, "uuidRoute");
+
 // src/routes/http-methods/delete.ts
 var deleteSchema = {
   description: "Handles a DELETE request and returns request information",
@@ -1148,6 +2252,18 @@ var indexRoute = /* @__PURE__ */ __name((fastify) => {
     <meta
       name="viewport"
       content="width=device-width, initial-scale=1" />
+    <meta name="description" content="MockHttp - A powerful HTTP mock server and httpbin replacement for API testing. Built with Fastify, TypeScript, and Docker support." />
+    <meta name="keywords" content="mock, http, httpbin, testing, api, fastify, docker, typescript, rest, mock-server, api-testing, http-testing, httpbin-alternative" />
+    <meta property="og:title" content="MockHttp - HTTP Mock Server" />
+    <meta property="og:description" content="A powerful HTTP mock server and httpbin replacement for API testing. Built with Fastify, TypeScript, and Docker support." />
+    <meta property="og:type" content="website" />
+    <meta property="og:url" content="https://mockhttp.org" />
+    <meta property="og:image" content="https://mockhttp.org/logo.png" />
+    <meta property="og:site_name" content="MockHttp" />
+    <meta name="twitter:card" content="summary" />
+    <meta name="twitter:title" content="MockHttp - HTTP Mock Server" />
+    <meta name="twitter:description" content="A powerful HTTP mock server and httpbin replacement for API testing." />
+    <meta name="twitter:image" content="https://mockhttp.org/logo.png" />
       <style>
       :root {
   --scalar-custom-header-height: 70px;
@@ -2716,7 +3832,7 @@ import { fastifySwaggerUi } from "@fastify/swagger-ui";
 // package.json
 var package_default = {
   name: "@jaredwray/mockhttp",
-  version: "1.2.0",
+  version: "1.4.0",
   description: "Mock Http - Easy way to mock http with httpbin replacement",
   type: "module",
   main: "dist/index.js",
@@ -2767,36 +3883,41 @@ var package_default = {
   },
   homepage: "https://github.com/jaredwray/mockhttp#readme",
   devDependencies: {
-    "@biomejs/biome": "^2.3.8",
-    "@swc/core": "^1.15.3",
+    "@biomejs/biome": "^2.3.14",
+    "@swc/core": "^1.15.11",
     "@types/html-escaper": "^3.0.4",
-    "@vitest/coverage-v8": "^4.0.15",
+    "@vitest/coverage-v8": "^4.0.18",
     rimraf: "^6.1.2",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
     typescript: "^5.9.3",
-    vitest: "^4.0.15"
+    vitest: "^4.0.18"
   },
   dependencies: {
     "@fastify/cookie": "^11.0.2",
     "@fastify/helmet": "^13.0.2",
     "@fastify/rate-limit": "^10.3.0",
-    "@fastify/static": "^8.3.0",
-    "@fastify/swagger": "^9.6.1",
-    "@fastify/swagger-ui": "^5.2.3",
-    "@scalar/api-reference": "^1.40.4",
+    "@fastify/static": "^9.0.0",
+    "@fastify/swagger": "^9.7.0",
+    "@fastify/swagger-ui": "^5.2.5",
+    "@scalar/api-reference": "^1.44.16",
     "detect-port": "^2.1.0",
-    fastify: "^5.6.2",
-    hookified: "^1.14.0",
+    fastify: "^5.7.4",
+    hookified: "^1.15.1",
     "html-escaper": "^3.0.3",
-    pino: "^10.1.0",
+    pino: "^10.3.1",
     "pino-pretty": "^13.1.3"
   },
   files: [
     "dist",
     "public",
     "LICENCE"
-  ]
+  ],
+  pnpm: {
+    overrides: {
+      "set-cookie-parser": "2.7.2"
+    }
+  }
 };
 
 // src/swagger.ts
@@ -2851,7 +3972,7 @@ var registerSwaggerUi = /* @__PURE__ */ __name(async (fastify) => {
 }, "registerSwaggerUi");
 
 // src/tap-manager.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var TapManager = class {
   static {
     __name(this, "TapManager");
@@ -2879,7 +4000,7 @@ var TapManager = class {
   * @returns A tap object that can be used to remove the injection
   */
   inject(response, matcher) {
-    const id = randomUUID();
+    const id = randomUUID2();
     const tap = {
       id,
       response,
@@ -2992,7 +4113,8 @@ var MockHttp = class extends Hookified {
     cookies: true,
     anything: true,
     auth: true,
-    images: true
+    images: true,
+    dynamicData: true
   };
   _rateLimit = {
     max: 1e3,
@@ -3002,6 +4124,8 @@ var MockHttp = class extends Hookified {
       "::1"
     ]
   };
+  _https;
+  _httpsCredentials;
   _server = Fastify();
   _taps = new TapManager();
   constructor(options) {
@@ -3031,6 +4155,17 @@ var MockHttp = class extends Hookified {
     if (options?.logging !== void 0) {
       this._logging = options.logging;
     }
+    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.
@@ -3117,6 +4252,34 @@ 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;
+  }
+  /**
   * HTTP Bin options. Defaults to all enabled.
   */
   get httpBin() {
@@ -3174,11 +4337,25 @@ 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));
+      if (this._httpsCredentials) {
+        this._server = Fastify({
+          ...getFastifyConfig(this._logging),
+          https: {
+            key: this._httpsCredentials.key,
+            cert: this._httpsCredentials.cert
+          }
+        });
+      } else {
+        this._server = Fastify(getFastifyConfig(this._logging));
+      }
       this._server.addHook("onRequest", async (request, reply) => {
         const matchedTap = this._taps.matchRequest(request);
         if (matchedTap) {
@@ -3247,7 +4424,7 @@ var MockHttp = class extends Hookified {
       if (this._apiDocs) {
         await this.registerApiDocs();
       }
-      const { httpMethods, redirects, requestInspection, responseInspection, responseFormats, statusCodes: statusCodes2, cookies, anything, auth, images } = this._httpBin;
+      const { httpMethods, redirects, requestInspection, responseInspection, responseFormats, statusCodes: statusCodes2, cookies, anything, auth, images, dynamicData } = this._httpBin;
       if (httpMethods) {
         await this.registerHttpMethods();
       }
@@ -3278,6 +4455,9 @@ var MockHttp = class extends Hookified {
       if (images) {
         await this.registerImageRoutes();
       }
+      if (dynamicData) {
+        await this.registerDynamicDataRoutes();
+      }
       if (this._autoDetectPort) {
         const originalPort = this._port;
         this._port = await this.detectPort();
@@ -3409,6 +4589,49 @@ var MockHttp = class extends Hookified {
     const fastify = fastifyInstance ?? this._server;
     await fastify.register(imageRoutes);
   }
+  /**
+  * Register the dynamic data routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerDynamicDataRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(uuidRoute);
+    await fastify.register(bytesRoute);
+    await fastify.register(streamBytesRoute);
+    await fastify.register(delayRoute);
+    await fastify.register(base64Route);
+    await fastify.register(streamRoute);
+    await fastify.register(rangeRoute);
+    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
@@ -3431,7 +4654,11 @@ if (import.meta.url === `file://${process2.argv[1]}`) {
 }
 export {
   MockHttp as default,
+  generateCertificate,
+  generateCertificateFiles,
   MockHttp as mockhttp,
   start
 };
 /* v8 ignore next -- @preserve */
+/* v8 ignore next 2 -- @preserve */
+/* v8 ignore next 3 -- @preserve */