@jaredwray/mockhttp 1.8.1 → 1.9.0

package/dist/index.d.mts

@@ -1,34 +1,51 @@
 import { RateLimitPluginOptions } from "@fastify/rate-limit";
 import { FastifyInstance, FastifyRequest } from "fastify";
 import { Hookified, HookifiedOptions } from "hookified";
-
 //#region src/bin-store.d.ts
 /**
  * A request captured by a bin, including method, headers, body and metadata.
  */
 type CapturedRequest = {
-  /** Unique identifier for this captured request */id: string; /** Identifier of the bin that captured this request */
-  binId: string; /** HTTP method (GET, POST, etc.) */
-  method: string; /** Request URL path + query, relative to the bin (e.g. "/foo?x=1") */
-  url: string; /** Sub-path after the bin id ("/" if the request hit the bin root) */
-  path: string; /** Parsed query string parameters */
-  query: Record<string, string | string[]>; /** Request headers */
-  headers: Record<string, string | string[]>; /** Client IP address as reported by Fastify */
-  remoteAddress: string; /** Content-Type header value, if any */
-  contentType?: string; /** Original body length in bytes */
-  bodySize: number; /** Body payload as utf8 text, base64-encoded bytes, or null when empty */
-  body: string | null; /** Encoding used for the `body` field */
-  bodyEncoding: "utf8" | "base64" | "none"; /** True if the body was longer than the configured `maxBodySize` */
-  truncated: boolean; /** ISO timestamp of when the request was captured */
+  /** Unique identifier for this captured request */
+  id: string;
+  /** Identifier of the bin that captured this request */
+  binId: string;
+  /** HTTP method (GET, POST, etc.) */
+  method: string;
+  /** Request URL path + query, relative to the bin (e.g. "/foo?x=1") */
+  url: string;
+  /** Sub-path after the bin id ("/" if the request hit the bin root) */
+  path: string;
+  /** Parsed query string parameters */
+  query: Record<string, string | string[]>;
+  /** Request headers */
+  headers: Record<string, string | string[]>;
+  /** Client IP address as reported by Fastify */
+  remoteAddress: string;
+  /** Content-Type header value, if any */
+  contentType?: string;
+  /** Original body length in bytes */
+  bodySize: number;
+  /** Body payload as utf8 text, base64-encoded bytes, or null when empty */
+  body: string | null;
+  /** Encoding used for the `body` field */
+  bodyEncoding: "utf8" | "base64" | "none";
+  /** True if the body was longer than the configured `maxBodySize` */
+  truncated: boolean;
+  /** ISO timestamp of when the request was captured */
   capturedAt: string;
 };
 /**
  * Metadata for a bin (without its captured requests).
  */
 type Bin = {
-  /** Unique short identifier for the bin */id: string; /** ISO timestamp of bin creation */
-  createdAt: string; /** ISO timestamp at which the bin expires */
-  expiresAt: string; /** Number of requests currently stored in the bin */
+  /** Unique short identifier for the bin */
+  id: string;
+  /** ISO timestamp of bin creation */
+  createdAt: string;
+  /** ISO timestamp at which the bin expires */
+  expiresAt: string;
+  /** Number of requests currently stored in the bin */
   requestCount: number;
 };
 /**
@@ -85,11 +102,17 @@ declare class InMemoryBinStore implements BinStore {
  * Configuration options for {@link BinManager}.
  */
 type BinManagerOptions = {
-  /** Storage backend. Defaults to a new {@link InMemoryBinStore}. */store?: BinStore; /** Bin lifetime in milliseconds. Defaults to 24 hours. */
-  defaultTtlMs?: number; /** Maximum number of requests retained per bin (FIFO). Defaults to 100. */
-  maxRequestsPerBin?: number; /** Maximum captured body size in bytes. Larger bodies are truncated. Defaults to 1 MiB. */
-  maxBodySize?: number; /** Length of generated bin and request ids. Defaults to 12. */
-  idLength?: number; /** Interval between cleanup sweeps in milliseconds. Defaults to 1 minute. */
+  /** Storage backend. Defaults to a new {@link InMemoryBinStore}. */
+  store?: BinStore;
+  /** Bin lifetime in milliseconds. Defaults to 24 hours. */
+  defaultTtlMs?: number;
+  /** Maximum number of requests retained per bin (FIFO). Defaults to 100. */
+  maxRequestsPerBin?: number;
+  /** Maximum captured body size in bytes. Larger bodies are truncated. Defaults to 1 MiB. */
+  maxBodySize?: number;
+  /** Length of generated bin and request ids. Defaults to 12. */
+  idLength?: number;
+  /** Interval between cleanup sweeps in milliseconds. Defaults to 1 minute. */
   cleanupIntervalMs?: number;
 };
 /**

package/dist/index.mjs

@@ -70,9 +70,9 @@ var InMemoryBinStore = class {
 };
 //#endregion
 //#region src/bin-manager.ts
-const DEFAULT_TTL_MS = 1440 * 60 * 1e3;
+const DEFAULT_TTL_MS = 864e5;
 const DEFAULT_MAX_REQUESTS = 100;
-const DEFAULT_MAX_BODY_SIZE = 1024 * 1024;
+const DEFAULT_MAX_BODY_SIZE = 1048576;
 const DEFAULT_ID_LENGTH = 12;
 const DEFAULT_CLEANUP_INTERVAL_MS = 6e4;
 /**
@@ -228,18 +228,19 @@ function encodeSet(...elements) {
 }
 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]);
+	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);
 }
@@ -690,7 +691,7 @@ const bearerAuthRoute = (fastify) => {
 //#endregion
 //#region src/routes/auth/digest.ts
 const makeNonce = () => crypto.randomBytes(16).toString("hex");
-const algorithms = new Set([
+const algorithms = /* @__PURE__ */ new Set([
 	"MD5",
 	"md5",
 	"SHA-256",
@@ -1374,7 +1375,7 @@ function generateSeededBytes$1(n, seed) {
 	for (let i = 0; i < n; i++) bytes[i] = Math.floor(random() * 256);
 	return bytes;
 }
-const MAX_BYTES$3 = 100 * 1024;
+const MAX_BYTES$3 = 102400;
 const bytesRoute = (fastify) => {
 	fastify.get("/bytes/:n", { schema: bytesSchema }, async (request, reply) => {
 		const n = Number.parseInt(request.params.n, 10);
@@ -1501,7 +1502,7 @@ const DEFAULT_CODE = 200;
 const DEFAULT_DELAY = 2;
 const MAX_DURATION = 10;
 const MAX_DELAY = 10;
-const MAX_BYTES$2 = 10 * 1024 * 1024;
+const MAX_BYTES$2 = 10485760;
 const dripRoute = (fastify) => {
 	fastify.get("/drip", { schema: dripSchema }, async (request, reply) => {
 		/* v8 ignore next 2 -- @preserve */
@@ -1627,7 +1628,7 @@ const rangeSchema = {
 		}
 	}
 };
-const MAX_BYTES$1 = 100 * 1024;
+const MAX_BYTES$1 = 102400;
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1808,7 +1809,7 @@ function generateSeededBytes(n, seed) {
 	for (let i = 0; i < n; i++) bytes[i] = Math.floor(random() * 256);
 	return bytes;
 }
-const MAX_BYTES = 100 * 1024;
+const MAX_BYTES = 102400;
 const DEFAULT_CHUNK_SIZE = 10240;
 const streamBytesRoute = (fastify) => {
 	fastify.get("/stream-bytes/:n", { schema: streamBytesSchema }, async (request, reply) => {
@@ -2115,7 +2116,8 @@ const imageRoutes = (fastify) => {
 			contentType = "image/png";
 		}
 		try {
-			const imageBuffer = readFileSync(join(publicPath, file));
+			const imagePath = join(publicPath, file);
+			const imageBuffer = readFileSync(imagePath);
 			reply.type(contentType);
 			return imageBuffer;
 		} catch (error) {
@@ -2127,7 +2129,8 @@ const imageRoutes = (fastify) => {
 	});
 	fastify.get("/image/jpeg", { schema: jpegSchema }, async (_request, reply) => {
 		try {
-			const imageBuffer = readFileSync(join(publicPath, "logo.jpg"));
+			const imagePath = join(publicPath, "logo.jpg");
+			const imageBuffer = readFileSync(imagePath);
 			reply.type("image/jpeg");
 			return imageBuffer;
 		} catch (error) {
@@ -2139,7 +2142,8 @@ const imageRoutes = (fastify) => {
 	});
 	fastify.get("/image/png", { schema: pngSchema }, async (_request, reply) => {
 		try {
-			const imageBuffer = readFileSync(join(publicPath, "logo.png"));
+			const imagePath = join(publicPath, "logo.png");
+			const imageBuffer = readFileSync(imagePath);
 			reply.type("image/png");
 			return imageBuffer;
 		} catch (error) {
@@ -2151,7 +2155,8 @@ const imageRoutes = (fastify) => {
 	});
 	fastify.get("/image/svg", { schema: svgSchema }, async (_request, reply) => {
 		try {
-			const imageBuffer = readFileSync(join(publicPath, "logo.svg"));
+			const imagePath = join(publicPath, "logo.svg");
+			const imageBuffer = readFileSync(imagePath);
 			reply.type("image/svg+xml");
 			return imageBuffer;
 		} catch (error) {
@@ -2163,7 +2168,8 @@ const imageRoutes = (fastify) => {
 	});
 	fastify.get("/image/webp", { schema: webpSchema }, async (_request, reply) => {
 		try {
-			const imageBuffer = readFileSync(join(publicPath, "logo.webp"));
+			const imagePath = join(publicPath, "logo.webp");
+			const imageBuffer = readFileSync(imagePath);
 			reply.type("image/webp");
 			return imageBuffer;
 		} catch (error) {
@@ -2438,46 +2444,78 @@ const userAgentRoute = (fastify) => {
 };
 //#endregion
 //#region src/routes/response-formats/index.ts
-const plainSchema = {
-	description: "Returns random plain text content",
-	tags: ["Response Formats"],
-	response: { 200: {
+const templateIndexParams = {
+	type: "object",
+	properties: { index: {
 		type: "string",
-		description: "Random plain text content"
+		description: "Optional 1-based template index for stable, repeatable output. Omit for a random template."
 	} }
 };
+const templateNotFoundResponse = {
+	type: "object",
+	description: "The requested template index does not exist",
+	properties: { error: { type: "string" } }
+};
+const plainSchema = {
+	description: "Returns plain text content. A random template is selected unless a 1-based template index is provided (e.g. /plain/1) for stable output.",
+	tags: ["Response Formats"],
+	params: templateIndexParams,
+	response: {
+		200: {
+			type: "string",
+			description: "Plain text content"
+		},
+		404: templateNotFoundResponse
+	}
+};
 const textSchema = {
-	description: "Returns random text content",
+	description: "Returns text content. A random template is selected unless a 1-based template index is provided (e.g. /text/1) for stable output.",
 	tags: ["Response Formats"],
-	response: { 200: {
-		type: "string",
-		description: "Random text content"
-	} }
+	params: templateIndexParams,
+	response: {
+		200: {
+			type: "string",
+			description: "Text content"
+		},
+		404: templateNotFoundResponse
+	}
 };
 const htmlSchema = {
-	description: "Returns random HTML content",
+	description: "Returns HTML content. A random template is selected unless a 1-based template index is provided (e.g. /html/1) for stable output.",
 	tags: ["Response Formats"],
-	response: { 200: {
-		type: "string",
-		description: "Random HTML content"
-	} }
+	params: templateIndexParams,
+	response: {
+		200: {
+			type: "string",
+			description: "HTML content"
+		},
+		404: templateNotFoundResponse
+	}
 };
 const xmlSchema = {
-	description: "Returns random XML content",
+	description: "Returns XML content. A random template is selected unless a 1-based template index is provided (e.g. /xml/1) for stable output.",
 	tags: ["Response Formats"],
-	response: { 200: {
-		type: "string",
-		description: "Random XML content"
-	} }
+	params: templateIndexParams,
+	response: {
+		200: {
+			type: "string",
+			description: "XML content"
+		},
+		404: templateNotFoundResponse
+	}
 };
 const jsonSchema = {
-	description: "Returns random JSON content",
+	description: "Returns JSON content. A random template is selected unless a 1-based template index is provided (e.g. /json/1) for stable output.",
 	tags: ["Response Formats"],
-	response: { 200: {
-		type: "object",
-		description: "Random JSON content",
-		additionalProperties: true
-	} }
+	params: templateIndexParams,
+	response: {
+		200: {
+			type: "object",
+			description: "JSON content",
+			additionalProperties: true
+		},
+		404: templateNotFoundResponse
+	}
 };
 const denySchema = {
 	description: "Returns page denied by robots.txt rules",
@@ -2613,7 +2651,7 @@ const randomXmlContent = [
 	`<?xml version="1.0" encoding="UTF-8"?>
 <root>
     <message>Hello from MockHTTP</message>
-    <timestamp>${(/* @__PURE__ */ new Date()).toISOString()}</timestamp>
+    <timestamp>2024-01-15T10:30:00.000Z</timestamp>
     <status>success</status>
 </root>`,
 	`<?xml version="1.0" encoding="UTF-8"?>
@@ -2656,19 +2694,19 @@ const randomXmlContent = [
             <title>First Article</title>
             <link>http://example.com/article1</link>
             <description>This is the first article in our feed</description>
-            <pubDate>${(/* @__PURE__ */ new Date()).toUTCString()}</pubDate>
+            <pubDate>Mon, 15 Jan 2024 10:30:00 GMT</pubDate>
         </item>
     </channel>
 </rss>`
 ];
 const randomJsonContent = [
-	() => ({
+	{
 		message: "Hello from MockHTTP",
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		timestamp: "2024-01-15T10:30:00.000Z",
 		status: "success",
 		code: 200
-	}),
-	() => ({
+	},
+	{
 		user: {
 			id: 1,
 			name: "John Doe",
@@ -2681,8 +2719,8 @@ const randomJsonContent = [
 			"write",
 			"delete"
 		]
-	}),
-	() => ({
+	},
+	{
 		products: [{
 			id: 101,
 			name: "Laptop",
@@ -2696,8 +2734,8 @@ const randomJsonContent = [
 		}],
 		total: 2,
 		page: 1
-	}),
-	() => ({ config: {
+	},
+	{ config: {
 		theme: "dark",
 		language: "en",
 		notifications: {
@@ -2709,8 +2747,8 @@ const randomJsonContent = [
 			profile: "public",
 			activity: "friends"
 		}
-	} }),
-	() => ({ metrics: {
+	} },
+	{ metrics: {
 		cpu: 45.2,
 		memory: 78.5,
 		disk: 62.3,
@@ -2733,60 +2771,71 @@ const randomJsonContent = [
 				status: "warning"
 			}
 		]
-	} })
+	} }
 ];
+const resolveTemplateIndex = (index, length) => {
+	if (index === void 0) return Math.floor(Math.random() * length);
+	const value = Number(index);
+	if (!Number.isInteger(value) || value < 1 || value > length) return -1;
+	return value - 1;
+};
+const templateNotFound = (reply, length) => reply.code(404).send({ error: `Template index must be between 1 and ${length}` });
 const responseFormatRoutes = (fastify) => {
-	const plainHandler = async (_request, reply) => {
-		const text = randomTexts[Math.floor(Math.random() * randomTexts.length)];
+	const plainHandler = async (request, reply) => {
+		const index = resolveTemplateIndex(request.params.index, randomTexts.length);
+		if (index === -1) return templateNotFound(reply, randomTexts.length);
 		reply.type("text/plain");
-		return text;
+		return randomTexts[index];
 	};
-	fastify.get("/plain", { schema: plainSchema }, plainHandler);
-	fastify.post("/plain", { schema: plainSchema }, plainHandler);
-	fastify.put("/plain", { schema: plainSchema }, plainHandler);
-	fastify.patch("/plain", { schema: plainSchema }, plainHandler);
-	fastify.delete("/plain", { schema: plainSchema }, plainHandler);
-	const textHandler = async (_request, reply) => {
-		const text = randomTexts[Math.floor(Math.random() * randomTexts.length)];
+	fastify.get("/plain/:index?", { schema: plainSchema }, plainHandler);
+	fastify.post("/plain/:index?", { schema: plainSchema }, plainHandler);
+	fastify.put("/plain/:index?", { schema: plainSchema }, plainHandler);
+	fastify.patch("/plain/:index?", { schema: plainSchema }, plainHandler);
+	fastify.delete("/plain/:index?", { schema: plainSchema }, plainHandler);
+	const textHandler = async (request, reply) => {
+		const index = resolveTemplateIndex(request.params.index, randomTexts.length);
+		if (index === -1) return templateNotFound(reply, randomTexts.length);
 		reply.type("text/plain");
-		return text;
+		return randomTexts[index];
 	};
-	fastify.get("/text", { schema: textSchema }, textHandler);
-	fastify.post("/text", { schema: textSchema }, textHandler);
-	fastify.put("/text", { schema: textSchema }, textHandler);
-	fastify.patch("/text", { schema: textSchema }, textHandler);
-	fastify.delete("/text", { schema: textSchema }, textHandler);
-	const htmlHandler = async (_request, reply) => {
-		const html = randomHtmlContent[Math.floor(Math.random() * randomHtmlContent.length)];
+	fastify.get("/text/:index?", { schema: textSchema }, textHandler);
+	fastify.post("/text/:index?", { schema: textSchema }, textHandler);
+	fastify.put("/text/:index?", { schema: textSchema }, textHandler);
+	fastify.patch("/text/:index?", { schema: textSchema }, textHandler);
+	fastify.delete("/text/:index?", { schema: textSchema }, textHandler);
+	const htmlHandler = async (request, reply) => {
+		const index = resolveTemplateIndex(request.params.index, randomHtmlContent.length);
+		if (index === -1) return templateNotFound(reply, randomHtmlContent.length);
 		reply.type("text/html");
-		return html;
+		return randomHtmlContent[index];
 	};
-	fastify.get("/html", { schema: htmlSchema }, htmlHandler);
-	fastify.post("/html", { schema: htmlSchema }, htmlHandler);
-	fastify.put("/html", { schema: htmlSchema }, htmlHandler);
-	fastify.patch("/html", { schema: htmlSchema }, htmlHandler);
-	fastify.delete("/html", { schema: htmlSchema }, htmlHandler);
-	const xmlHandler = async (_request, reply) => {
-		const xml = randomXmlContent[Math.floor(Math.random() * randomXmlContent.length)];
+	fastify.get("/html/:index?", { schema: htmlSchema }, htmlHandler);
+	fastify.post("/html/:index?", { schema: htmlSchema }, htmlHandler);
+	fastify.put("/html/:index?", { schema: htmlSchema }, htmlHandler);
+	fastify.patch("/html/:index?", { schema: htmlSchema }, htmlHandler);
+	fastify.delete("/html/:index?", { schema: htmlSchema }, htmlHandler);
+	const xmlHandler = async (request, reply) => {
+		const index = resolveTemplateIndex(request.params.index, randomXmlContent.length);
+		if (index === -1) return templateNotFound(reply, randomXmlContent.length);
 		reply.type("application/xml");
-		return xml;
+		return randomXmlContent[index];
 	};
-	fastify.get("/xml", { schema: xmlSchema }, xmlHandler);
-	fastify.post("/xml", { schema: xmlSchema }, xmlHandler);
-	fastify.put("/xml", { schema: xmlSchema }, xmlHandler);
-	fastify.patch("/xml", { schema: xmlSchema }, xmlHandler);
-	fastify.delete("/xml", { schema: xmlSchema }, xmlHandler);
-	const jsonHandler = async (_request, reply) => {
-		const jsonGenerator = randomJsonContent[Math.floor(Math.random() * randomJsonContent.length)];
-		const json = jsonGenerator();
+	fastify.get("/xml/:index?", { schema: xmlSchema }, xmlHandler);
+	fastify.post("/xml/:index?", { schema: xmlSchema }, xmlHandler);
+	fastify.put("/xml/:index?", { schema: xmlSchema }, xmlHandler);
+	fastify.patch("/xml/:index?", { schema: xmlSchema }, xmlHandler);
+	fastify.delete("/xml/:index?", { schema: xmlSchema }, xmlHandler);
+	const jsonHandler = async (request, reply) => {
+		const index = resolveTemplateIndex(request.params.index, randomJsonContent.length);
+		if (index === -1) return templateNotFound(reply, randomJsonContent.length);
 		reply.type("application/json");
-		return json;
+		return structuredClone(randomJsonContent[index]);
 	};
-	fastify.get("/json", { schema: jsonSchema }, jsonHandler);
-	fastify.post("/json", { schema: jsonSchema }, jsonHandler);
-	fastify.put("/json", { schema: jsonSchema }, jsonHandler);
-	fastify.patch("/json", { schema: jsonSchema }, jsonHandler);
-	fastify.delete("/json", { schema: jsonSchema }, jsonHandler);
+	fastify.get("/json/:index?", { schema: jsonSchema }, jsonHandler);
+	fastify.post("/json/:index?", { schema: jsonSchema }, jsonHandler);
+	fastify.put("/json/:index?", { schema: jsonSchema }, jsonHandler);
+	fastify.patch("/json/:index?", { schema: jsonSchema }, jsonHandler);
+	fastify.delete("/json/:index?", { schema: jsonSchema }, jsonHandler);
 	const denyHandler = async (_request, reply) => {
 		const denyMessages = [
 			`<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
@@ -2869,7 +2918,8 @@ const responseFormatRoutes = (fastify) => {
 				...data,
 				compressedSize: compressed.length
 			};
-			const updatedCompressed = gzipSync(JSON.stringify(updatedData));
+			const updatedJsonString = JSON.stringify(updatedData);
+			const updatedCompressed = gzipSync(updatedJsonString);
 			reply.header("Content-Encoding", "gzip");
 			reply.header("Content-Type", "application/json");
 			reply.type("application/octet-stream");
@@ -2925,7 +2975,8 @@ const responseFormatRoutes = (fastify) => {
 				...data,
 				compressedSize: compressed.length
 			};
-			const updatedCompressed = deflateSync(JSON.stringify(updatedData));
+			const updatedJsonString = JSON.stringify(updatedData);
+			const updatedCompressed = deflateSync(updatedJsonString);
 			reply.header("Content-Encoding", "deflate");
 			reply.header("Content-Type", "application/json");
 			reply.type("application/octet-stream");
@@ -2986,7 +3037,8 @@ const responseFormatRoutes = (fastify) => {
 				...data,
 				compressedSize: compressed.length
 			};
-			const updatedCompressed = brotliCompressSync(JSON.stringify(updatedData));
+			const updatedJsonString = JSON.stringify(updatedData);
+			const updatedCompressed = brotliCompressSync(updatedJsonString);
 			reply.header("Content-Encoding", "br");
 			reply.header("Content-Type", "application/json");
 			reply.type("application/octet-stream");
@@ -3449,7 +3501,7 @@ A simple HTTP server that can be used to mock HTTP responses for testing purpose
 
 [mockhttp.org](https://mockhttp.org) is a free service that runs this codebase and allows you to use it for testing purposes. It is a simple way to mock HTTP responses for testing purposes. Ran via [Cloudflare](https://cloudflare.com) and [Google Cloud Run](https://cloud.google.com/run/) across 7 regions globally and can do millions of requests per second.
 `,
-		version: "1.8.1"
+		version: "1.9.0"
 	},
 	consumes: ["application/json"],
 	produces: ["application/json"]
@@ -3618,14 +3670,18 @@ var MockHttp = class extends Hookified {
 		if (options?.helmet !== void 0) this._helmet = options.helmet;
 		if (options?.apiDocs !== void 0) this._apiDocs = options.apiDocs;
 		if (options?.httpBin !== void 0) this._httpBin = options.httpBin;
-		if (options?.rateLimit !== void 0) if (options.rateLimit === false) this._rateLimit = void 0;
-		else this._rateLimit = options.rateLimit;
+		if (options?.rateLimit !== void 0) {
+			if (options.rateLimit === false) this._rateLimit = void 0;
+			else this._rateLimit = options.rateLimit;
+		}
 		if (options?.logging !== void 0) this._logging = options.logging;
 		if (options?.http2 !== void 0) this._http2 = options.http2;
 		if (options?.http1 !== void 0) this._http1 = options.http1;
-		if (options?.https !== void 0) if (options.https === true) this._https = { autoGenerate: true };
-		else if (options.https === false) this._https = void 0;
-		else this._https = options.https;
+		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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaredwray/mockhttp",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "Mock Http - Easy way to mock http with httpbin replacement",
   "type": "module",
   "main": "dist/index.mjs",
@@ -39,27 +39,27 @@
   },
   "homepage": "https://github.com/jaredwray/mockhttp#readme",
   "devDependencies": {
-    "@biomejs/biome": "^2.5.3",
-    "@swc/core": "^1.15.43",
+    "@biomejs/biome": "^2.5.8",
+    "@swc/core": "^1.15.47",
     "@types/html-escaper": "^3.0.4",
     "@vitest/coverage-v8": "^4.1.10",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.2",
-    "tsx": "^4.23.0",
-    "typescript": "6.0.3",
+    "tsdown": "^0.22.14",
+    "tsx": "^4.23.12",
+    "typescript": "7.0.2",
     "vitest": "^4.1.10"
   },
   "dependencies": {
-    "@fastify/cookie": "^11.1.1",
+    "@fastify/cookie": "^11.1.2",
     "@fastify/helmet": "^13.1.0",
-    "@fastify/rate-limit": "^11.1.0",
-    "@fastify/static": "^10.1.0",
-    "@fastify/swagger": "^9.8.0",
-    "@fastify/swagger-ui": "^6.1.0",
-    "@scalar/api-reference": "^1.62.5",
+    "@fastify/rate-limit": "^11.2.0",
+    "@fastify/static": "^10.1.3",
+    "@fastify/swagger": "^9.8.1",
+    "@fastify/swagger-ui": "^6.1.1",
+    "@scalar/api-reference": "^1.64.1",
     "detect-port": "^2.1.0",
-    "fastify": "^5.10.0",
-    "hookified": "^3.0.1",
+    "fastify": "^5.11.3",
+    "hookified": "^3.0.2",
     "html-escaper": "^3.0.3",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3"