@jaredwray/mockhttp 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -132,6 +132,7 @@ type HttpBinOptions = {
     anything?: boolean;
     auth?: boolean;
     images?: boolean;
+    dynamicData?: boolean;
 };
 type MockHttpOptions = {
     /**
@@ -347,6 +348,11 @@ declare class MockHttp extends Hookified {
      * @param fastifyInstance - the server instance to register the routes on.
      */
     registerImageRoutes(fastifyInstance?: FastifyInstance): Promise<void>;
+    /**
+     * Register the dynamic data routes.
+     * @param fastifyInstance - the server instance to register the routes on.
+     */
+    registerDynamicDataRoutes(fastifyInstance?: FastifyInstance): Promise<void>;
 }
 
 declare const start: () => Promise<MockHttp>;

package/dist/index.js

@@ -712,6 +712,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 } 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 = randomBytes(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 randomBytes2 } 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 = randomBytes2(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 +1950,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 +3530,7 @@ import { fastifySwaggerUi } from "@fastify/swagger-ui";
 // package.json
 var package_default = {
   name: "@jaredwray/mockhttp",
-  version: "1.2.0",
+  version: "1.3.0",
   description: "Mock Http - Easy way to mock http with httpbin replacement",
   type: "module",
   main: "dist/index.js",
@@ -2767,36 +3581,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.11",
+    "@swc/core": "^1.15.8",
     "@types/html-escaper": "^3.0.4",
-    "@vitest/coverage-v8": "^4.0.15",
+    "@vitest/coverage-v8": "^4.0.16",
     rimraf: "^6.1.2",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
     typescript: "^5.9.3",
-    vitest: "^4.0.15"
+    vitest: "^4.0.16"
   },
   dependencies: {
     "@fastify/cookie": "^11.0.2",
     "@fastify/helmet": "^13.0.2",
     "@fastify/rate-limit": "^10.3.0",
-    "@fastify/static": "^8.3.0",
+    "@fastify/static": "^9.0.0",
     "@fastify/swagger": "^9.6.1",
-    "@fastify/swagger-ui": "^5.2.3",
-    "@scalar/api-reference": "^1.40.4",
+    "@fastify/swagger-ui": "^5.2.4",
+    "@scalar/api-reference": "^1.43.1",
     "detect-port": "^2.1.0",
     fastify: "^5.6.2",
-    hookified: "^1.14.0",
+    hookified: "^1.15.0",
     "html-escaper": "^3.0.3",
-    pino: "^10.1.0",
+    pino: "^10.1.1",
     "pino-pretty": "^13.1.3"
   },
   files: [
     "dist",
     "public",
     "LICENCE"
-  ]
+  ],
+  pnpm: {
+    overrides: {
+      "set-cookie-parser": "2.7.2"
+    }
+  }
 };
 
 // src/swagger.ts
@@ -2851,7 +3670,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 +3698,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 +3811,8 @@ var MockHttp = class extends Hookified {
     cookies: true,
     anything: true,
     auth: true,
-    images: true
+    images: true,
+    dynamicData: true
   };
   _rateLimit = {
     max: 1e3,
@@ -3247,7 +4067,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 +4098,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 +4232,22 @@ 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);
+  }
 };
 
 // src/index.ts
@@ -3435,3 +4274,5 @@ export {
   start
 };
 /* v8 ignore next -- @preserve */
+/* v8 ignore next 2 -- @preserve */
+/* v8 ignore next 3 -- @preserve */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jaredwray/mockhttp",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Mock Http - Easy way to mock http with httpbin replacement",
 	"type": "module",
 	"main": "dist/index.js",
@@ -51,34 +51,39 @@
 	},
 	"homepage": "https://github.com/jaredwray/mockhttp#readme",
 	"devDependencies": {
-		"@biomejs/biome": "^2.3.8",
-		"@swc/core": "^1.15.3",
+		"@biomejs/biome": "^2.3.11",
+		"@swc/core": "^1.15.8",
 		"@types/html-escaper": "^3.0.4",
-		"@vitest/coverage-v8": "^4.0.15",
+		"@vitest/coverage-v8": "^4.0.16",
 		"rimraf": "^6.1.2",
 		"tsup": "^8.5.1",
 		"tsx": "^4.21.0",
 		"typescript": "^5.9.3",
-		"vitest": "^4.0.15"
+		"vitest": "^4.0.16"
 	},
 	"dependencies": {
 		"@fastify/cookie": "^11.0.2",
 		"@fastify/helmet": "^13.0.2",
 		"@fastify/rate-limit": "^10.3.0",
-		"@fastify/static": "^8.3.0",
+		"@fastify/static": "^9.0.0",
 		"@fastify/swagger": "^9.6.1",
-		"@fastify/swagger-ui": "^5.2.3",
-		"@scalar/api-reference": "^1.40.4",
+		"@fastify/swagger-ui": "^5.2.4",
+		"@scalar/api-reference": "^1.43.1",
 		"detect-port": "^2.1.0",
 		"fastify": "^5.6.2",
-		"hookified": "^1.14.0",
+		"hookified": "^1.15.0",
 		"html-escaper": "^3.0.3",
-		"pino": "^10.1.0",
+		"pino": "^10.1.1",
 		"pino-pretty": "^13.1.3"
 	},
 	"files": [
 		"dist",
 		"public",
 		"LICENCE"
-	]
+	],
+	"pnpm": {
+		"overrides": {
+			"set-cookie-parser": "2.7.2"
+		}
+	}
 }