@jaredwray/mockhttp 1.1.0 → 1.3.0

package/README.md

@@ -21,6 +21,18 @@ A simple HTTP server that can be used to mock HTTP responses for testing purpose
 * Auto detect the port that is not in use
 * Maintained and updated regularly!
 
+# Table of Contents
+- [Deploy via Docker](#deploy-via-docker)
+- [Deploy via Docker Compose](#deploy-via-docker-compose)
+- [Deploy via NodeJS](#deploy-via-nodejs)
+- [Response Injection (Tap Feature)](#response-injection-tap-feature)
+- [Rate Limiting](#rate-limiting)
+- [Logging](#logging)
+- [API Reference](#api-reference)
+- [About mockhttp.org](#about-mockhttporg)
+- [Contributing](#contributing)
+- [License](#license)
+
 # Deploy via Docker
 ```bash
 docker run -d -p 3000:3000 jaredwray/mockhttp
@@ -405,6 +417,26 @@ await mock.start(); // Restarts with new settings
 
 For the complete list of options, see the [@fastify/rate-limit documentation](https://github.com/fastify/fastify-rate-limit#options).
 
+# Logging
+
+MockHttp uses [Pino](https://github.com/pinojs/pino) for logging via Fastify's built-in logger. Logging is **enabled by default** but can be disabled when needed.
+
+## Disabling Logging
+
+```javascript
+import { MockHttp } from '@jaredwray/mockhttp';
+
+const mock = new MockHttp({ logging: false });
+await mock.start();
+// Server runs silently without any log output
+```
+
+You can also disable logging via the `LOGGING` environment variable:
+
+```bash
+LOGGING=false node your-app.js
+```
+
 # API Reference
 
 ## MockHttp Class
@@ -423,6 +455,7 @@ new MockHttp(options?)
   - `helmet?`: boolean - Use Helmet for security headers (default: true)
   - `apiDocs?`: boolean - Enable Swagger API documentation (default: true)
   - `rateLimit?`: RateLimitPluginOptions - Configure rate limiting (default: 1000 req/min, localhost excluded)
+  - `logging?`: boolean - Enable logging (default: true)
   - `httpBin?`: HttpBinOptions - Configure which httpbin routes to enable
     - `httpMethods?`: boolean - Enable HTTP method routes (default: true)
     - `redirects?`: boolean - Enable redirect routes (default: true)
@@ -443,6 +476,7 @@ new MockHttp(options?)
 - `autoDetectPort`: boolean - Get/set auto-detect port behavior
 - `helmet`: boolean - Get/set Helmet security headers
 - `apiDocs`: boolean - Get/set API documentation
+- `logging`: boolean - Get/set logging enabled state
 - `rateLimit`: RateLimitPluginOptions | undefined - Get/set rate limiting options
 - `httpBin`: HttpBinOptions - Get/set httpbin route options
 - `server`: FastifyInstance - Get/set the Fastify server instance

package/dist/index.d.ts

@@ -132,6 +132,7 @@ type HttpBinOptions = {
     anything?: boolean;
     auth?: boolean;
     images?: boolean;
+    dynamicData?: boolean;
 };
 type MockHttpOptions = {
     /**
@@ -168,6 +169,10 @@ type MockHttpOptions = {
      * Hookified options.
      */
     hookOptions?: HookifiedOptions;
+    /**
+     * Whether to enable logging. Defaults to true.
+     */
+    logging?: boolean;
 };
 declare class MockHttp extends Hookified {
     private _port;
@@ -175,6 +180,7 @@ declare class MockHttp extends Hookified {
     private _autoDetectPort;
     private _helmet;
     private _apiDocs;
+    private _logging;
     private _httpBin;
     private _rateLimit?;
     private _server;
@@ -230,6 +236,16 @@ declare class MockHttp extends Hookified {
      * @default true
      */
     set apiDocs(apiDocs: boolean);
+    /**
+     * Whether to enable logging. Defaults to true.
+     * @default true
+     */
+    get logging(): boolean;
+    /**
+     * Whether to enable logging. Defaults to true.
+     * @default true
+     */
+    set logging(logging: boolean);
     /**
      * HTTP Bin options. Defaults to all enabled.
      */
@@ -332,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

@@ -16,19 +16,22 @@ import Fastify from "fastify";
 import { Hookified } from "hookified";
 
 // src/fastify-config.ts
-var fastifyConfig = {
-  logger: {
-    transport: {
-      target: "pino-pretty",
-      options: {
-        colorize: true,
-        translateTime: true,
-        ignore: "pid,hostname",
-        singleLine: true
+function getFastifyConfig(logging = true) {
+  return {
+    logger: logging ? {
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: true,
+          ignore: "pid,hostname",
+          singleLine: true
+        }
       }
-    }
-  }
-};
+    } : false
+  };
+}
+__name(getFastifyConfig, "getFastifyConfig");
 
 // src/routes/anything/index.ts
 var anythingSchema = {
@@ -709,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",
@@ -1145,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;
@@ -2713,7 +3530,7 @@ import { fastifySwaggerUi } from "@fastify/swagger-ui";
 // package.json
 var package_default = {
   name: "@jaredwray/mockhttp",
-  version: "1.1.0",
+  version: "1.3.0",
   description: "Mock Http - Easy way to mock http with httpbin replacement",
   type: "module",
   main: "dist/index.js",
@@ -2764,30 +3581,30 @@ var package_default = {
   },
   homepage: "https://github.com/jaredwray/mockhttp#readme",
   devDependencies: {
-    "@biomejs/biome": "^2.3.5",
-    "@swc/core": "^1.15.1",
+    "@biomejs/biome": "^2.3.11",
+    "@swc/core": "^1.15.8",
     "@types/html-escaper": "^3.0.4",
-    "@vitest/coverage-v8": "^4.0.8",
-    rimraf: "^6.1.0",
-    tsup: "^8.5.0",
-    tsx: "^4.20.6",
+    "@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.8"
+    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/swagger": "^9.6.0",
-    "@fastify/swagger-ui": "^5.2.3",
-    "@scalar/api-reference": "^1.39.3",
+    "@fastify/static": "^9.0.0",
+    "@fastify/swagger": "^9.6.1",
+    "@fastify/swagger-ui": "^5.2.4",
+    "@scalar/api-reference": "^1.43.1",
     "detect-port": "^2.1.0",
     fastify: "^5.6.2",
-    hookified: "^1.13.0",
+    hookified: "^1.15.0",
     "html-escaper": "^3.0.3",
-    pino: "^10.1.0",
-    "pino-pretty": "^13.1.2"
+    pino: "^10.1.1",
+    "pino-pretty": "^13.1.3"
   },
   files: [
     "dist",
@@ -2795,11 +3612,9 @@ var package_default = {
     "LICENCE"
   ],
   pnpm: {
-    onlyBuiltDependencies: [
-      "@swc/core",
-      "unrs-resolver",
-      "vue-demi"
-    ]
+    overrides: {
+      "set-cookie-parser": "2.7.2"
+    }
   }
 };
 
@@ -2855,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");
@@ -2883,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,
@@ -2985,6 +3800,7 @@ var MockHttp = class extends Hookified {
   _autoDetectPort = true;
   _helmet = true;
   _apiDocs = true;
+  _logging = true;
   _httpBin = {
     httpMethods: true,
     redirects: true,
@@ -2995,7 +3811,8 @@ var MockHttp = class extends Hookified {
     cookies: true,
     anything: true,
     auth: true,
-    images: true
+    images: true,
+    dynamicData: true
   };
   _rateLimit = {
     max: 1e3,
@@ -3031,6 +3848,9 @@ var MockHttp = class extends Hookified {
         this._rateLimit = options.rateLimit;
       }
     }
+    if (options?.logging !== void 0) {
+      this._logging = options.logging;
+    }
   }
   /**
   * The port to listen on. If not provided, defaults to 3000 and detects the next available port if in use.
@@ -3103,6 +3923,20 @@ var MockHttp = class extends Hookified {
     this._apiDocs = apiDocs;
   }
   /**
+  * Whether to enable logging. Defaults to true.
+  * @default true
+  */
+  get logging() {
+    return this._logging;
+  }
+  /**
+  * Whether to enable logging. Defaults to true.
+  * @default true
+  */
+  set logging(logging) {
+    this._logging = logging;
+  }
+  /**
   * HTTP Bin options. Defaults to all enabled.
   */
   get httpBin() {
@@ -3164,7 +3998,7 @@ var MockHttp = class extends Hookified {
       if (this._server) {
         await this._server.close();
       }
-      this._server = Fastify(fastifyConfig);
+      this._server = Fastify(getFastifyConfig(this._logging));
       this._server.addHook("onRequest", async (request, reply) => {
         const matchedTap = this._taps.matchRequest(request);
         if (matchedTap) {
@@ -3233,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();
       }
@@ -3264,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();
@@ -3395,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
@@ -3406,6 +4259,9 @@ var start = /* @__PURE__ */ __name(async () => {
   if (process2.env.HOST) {
     mockHttp.host = process2.env.HOST;
   }
+  if (process2.env.LOGGING === "false") {
+    mockHttp.logging = false;
+  }
   await mockHttp.start();
   return mockHttp;
 }, "start");
@@ -3418,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.1.0",
+	"version": "1.3.0",
 	"description": "Mock Http - Easy way to mock http with httpbin replacement",
 	"type": "module",
 	"main": "dist/index.js",
@@ -51,30 +51,30 @@
 	},
 	"homepage": "https://github.com/jaredwray/mockhttp#readme",
 	"devDependencies": {
-		"@biomejs/biome": "^2.3.5",
-		"@swc/core": "^1.15.1",
+		"@biomejs/biome": "^2.3.11",
+		"@swc/core": "^1.15.8",
 		"@types/html-escaper": "^3.0.4",
-		"@vitest/coverage-v8": "^4.0.8",
-		"rimraf": "^6.1.0",
-		"tsup": "^8.5.0",
-		"tsx": "^4.20.6",
+		"@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.8"
+		"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/swagger": "^9.6.0",
-		"@fastify/swagger-ui": "^5.2.3",
-		"@scalar/api-reference": "^1.39.3",
+		"@fastify/static": "^9.0.0",
+		"@fastify/swagger": "^9.6.1",
+		"@fastify/swagger-ui": "^5.2.4",
+		"@scalar/api-reference": "^1.43.1",
 		"detect-port": "^2.1.0",
 		"fastify": "^5.6.2",
-		"hookified": "^1.13.0",
+		"hookified": "^1.15.0",
 		"html-escaper": "^3.0.3",
-		"pino": "^10.1.0",
-		"pino-pretty": "^13.1.2"
+		"pino": "^10.1.1",
+		"pino-pretty": "^13.1.3"
 	},
 	"files": [
 		"dist",
@@ -82,10 +82,8 @@
 		"LICENCE"
 	],
 	"pnpm": {
-		"onlyBuiltDependencies": [
-			"@swc/core",
-			"unrs-resolver",
-			"vue-demi"
-		]
+		"overrides": {
+			"set-cookie-parser": "2.7.2"
+		}
 	}
 }