@jaredwray/mockhttp 0.0.1 → 0.2.0

package/dist/index.js

@@ -1,48 +1,1094 @@
-import process from 'node:process';
-import path from 'node:path';
-import Fastify from 'fastify';
-import fastifyStatic from '@fastify/static';
-import { fastifySwagger } from '@fastify/swagger';
-import { indexRoute } from './routes/index-route.js';
-import { fastifyConfig } from './fastify-config.js';
-import { fastifySwaggerConfig, registerSwaggerUi } from './swagger.js';
-import { ipRoute, headersRoute, userAgentRoute } from './routes/request-inspection/index.js';
-import { getRoute, postRoute, deleteRoute, putRoute, patchRoute, } from './routes/http-methods/index.js';
-import { statusCodeRoute } from './routes/status-codes/index.js';
-// eslint-disable-next-line new-cap
-const fastify = Fastify(fastifyConfig);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import process from "node:process";
+import path from "node:path";
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import { fastifySwagger } from "@fastify/swagger";
+import fastifyHelmet from "@fastify/helmet";
+
+// src/routes/index-route.ts
+var indexRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/", {
+    schema: {
+      hide: true
+    }
+  }, async (_request, reply) => {
+    const redocHtml = `
+	<!doctype html>
+<html>
+  <head>
+    <title>{ mockhttp }</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+      <style>
+      :root {
+  --scalar-custom-header-height: 70px;
+}
+.custom-header {
+  height: var(--scalar-custom-header-height);
+  background-color: var(--scalar-background-1);
+  box-shadow: inset 0 -1px 0 var(--scalar-border-color);
+  color: var(--scalar-color-1);
+  font-size: var(--scalar-font-size-2);
+  padding: 0 18px;
+  position: sticky;
+  justify-content: space-between;
+  top: 0;
+  z-index: 100;
+}
+.custom-header,
+.custom-header nav {
+  display: flex;
+  align-items: center;
+  gap: 18px;
+}
+
+.custom-header img {
+  height: var(--scalar-custom-header-height);
+  object-fit: contain;
+}
+
+.custom-header a:hover {
+  color: var(--scalar-color-2);
+}
+
+.github-corner {
+  fill: var(--scalar-border-color) !important;
+}
+
+      </style>
+  </head>
+  <body>
+  <header class="custom-header scalar-app">
+    <a href="/"><img src="/logo.svg" alt="{ mockhttp }" /></a>
+    <a href="https://github.com/jaredwray/mockhttp" class="github-corner" aria-label="View source on GitHub">
+      <svg width="70" height="70" viewBox="0 0 250 250" style="color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true"><path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a><style>.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}</style>
+  </header>
+
+    <script
+      id="api-reference"
+      data-url="/docs/json"></script>
+
+    <script src="/scalar/browser/standalone.js"></script>
+  </body>
+</html>
+`;
+    await reply.type("text/html").send(redocHtml);
+  });
+}, "indexRoute");
+
+// src/fastify-config.ts
+var fastifyConfig = {
+  logger: {
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: true,
+        ignore: "pid,hostname"
+      }
+    }
+  }
+};
+
+// src/swagger.ts
+import { fastifySwaggerUi } from "@fastify/swagger-ui";
+
+// package.json
+var package_default = {
+  name: "@jaredwray/mockhttp",
+  version: "0.2.0",
+  description: "Mock Http - Easy way to mock http with httpbin replacement",
+  type: "module",
+  main: "dist/index.js",
+  directories: {
+    test: "test"
+  },
+  scripts: {
+    test: "xo --fix && vitest run --coverage",
+    dev: "xo --fix && npx tsx src/index.ts --watch",
+    build: "rimraf ./dist && tsup src/index.ts --format esm --dts --clean",
+    "docker:build": "docker build -t jaredwray/mockhttp .",
+    "docker:run": "docker run -p 3000:3000 jaredwray/mockhttp",
+    "docker:push": "docker push jaredwray/mockhttp",
+    "docker:stop": 'docker stop $(docker ps -a -q --filter ancestor=jaredwray/mockhttp --format="{{.ID}}")',
+    prepare: "npm run build",
+    start: "node dist/index.js"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/jaredwray/mockhttp.git"
+  },
+  keywords: [
+    "mock",
+    "http",
+    "httpbin",
+    "test"
+  ],
+  author: "Jared Wray <me@jaredwray.com>",
+  license: "MIT",
+  bugs: {
+    url: "https://github.com/jaredwray/mockhttp/issues"
+  },
+  homepage: "https://github.com/jaredwray/mockhttp#readme",
+  devDependencies: {
+    "@swc/core": "^1.10.1",
+    "@types/html-escaper": "^3.0.2",
+    "@vitest/coverage-v8": "^2.1.8",
+    rimraf: "^6.0.1",
+    tsup: "^8.3.5",
+    tsx: "^4.19.2",
+    typescript: "^5.7.2",
+    vitest: "^2.1.8",
+    xo: "^0.60.0"
+  },
+  dependencies: {
+    "@fastify/helmet": "^13.0.0",
+    "@fastify/static": "^8.0.3",
+    "@fastify/swagger": "^9.4.0",
+    "@fastify/swagger-ui": "^5.2.0",
+    "@scalar/api-reference": "^1.25.80",
+    fastify: "^5.1.0",
+    "html-escaper": "^3.0.3",
+    pino: "^9.5.0",
+    "pino-pretty": "^13.0.0"
+  },
+  files: [
+    "dist",
+    "public",
+    "LICENCE"
+  ]
+};
+
+// src/swagger.ts
+var fastifySwaggerConfig = {
+  openapi: {
+    info: {
+      title: "Mock HTTP API",
+      description: "A replacement for httpbin built using Fastify and Typescript",
+      version: package_default.version
+    },
+    consumes: [
+      "application/json"
+    ],
+    produces: [
+      "application/json"
+    ]
+  }
+};
+var registerSwaggerUi = /* @__PURE__ */ __name(async (fastify2) => {
+  await fastify2.register(fastifySwaggerUi, {
+    routePrefix: "/docs",
+    uiConfig: {
+      docExpansion: "none",
+      deepLinking: false
+    },
+    uiHooks: {
+      /* c8 ignore next 6 */
+      onRequest(_request, _reply, next) {
+        next();
+      },
+      preHandler(_request, _reply, next) {
+        next();
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    staticCSP: true,
+    transformSpecification: /* @__PURE__ */ __name((swaggerObject, _request, _reply) => swaggerObject, "transformSpecification"),
+    transformSpecificationClone: true
+  });
+}, "registerSwaggerUi");
+
+// src/routes/request-inspection/ip.ts
+var ipSchema = {
+  description: "Returns the IP address of the client",
+  tags: [
+    "Request Inspection"
+  ],
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        ip: {
+          type: "string",
+          description: "The IP address of the client"
+        }
+      },
+      required: [
+        "ip"
+      ]
+    }
+  }
+};
+var ipRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/ip", {
+    schema: ipSchema
+  }, async (request) => {
+    const cloudflareIp = request.headers["cf-connecting-ip"];
+    const forwardedIp = request.headers["x-forwarded-for"];
+    const remoteIp = request.ip;
+    const ip = cloudflareIp ?? (typeof forwardedIp === "string" ? forwardedIp.split(",")[0].trim() : remoteIp);
+    return {
+      ip
+    };
+  });
+}, "ipRoute");
+
+// src/routes/request-inspection/headers.ts
+var headersSchema = {
+  description: "Returns all headers of the client request",
+  tags: [
+    "Request Inspection"
+  ],
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          },
+          description: "All headers of the client request"
+        }
+      },
+      required: [
+        "headers"
+      ]
+    }
+  }
+};
+var headersRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/headers", {
+    schema: headersSchema
+  }, async (request) => {
+    const headers = request.headers;
+    return {
+      headers
+    };
+  });
+}, "headersRoute");
+
+// src/routes/request-inspection/user-agent.ts
+var userAgentSchema = {
+  description: "Returns the User-Agent header of the client request",
+  tags: [
+    "Request Inspection"
+  ],
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        userAgent: {
+          type: "string",
+          description: "The User-Agent header of the client request"
+        }
+      },
+      required: [
+        "userAgent"
+      ]
+    }
+  }
+};
+var userAgentRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/user-agent", {
+    schema: userAgentSchema
+  }, async (request) => {
+    const userAgent = request.headers["user-agent"];
+    return {
+      userAgent
+    };
+  });
+}, "userAgentRoute");
+
+// src/routes/http-methods/get.ts
+var getSchema = {
+  description: "Returns request information for GET requests",
+  tags: [
+    "HTTP Methods"
+  ],
+  querystring: {
+    type: "object",
+    additionalProperties: true,
+    properties: {},
+    description: "Query parameters sent in the request"
+  },
+  headers: {
+    type: "object",
+    additionalProperties: true,
+    properties: {},
+    description: "Headers sent in the request"
+  },
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        queryParams: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "queryParams"
+      ]
+    }
+  }
+};
+var getRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/get", {
+    schema: getSchema
+  }, async (request, _reply) => ({
+    method: "GET",
+    headers: request.headers,
+    queryParams: request.query
+  }));
+}, "getRoute");
+
+// src/routes/http-methods/post.ts
+var postSchema = {
+  description: "Handles a POST request and returns request information",
+  tags: [
+    "HTTP Methods"
+  ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the POST request"
+  },
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+var postRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.post("/post", {
+    schema: postSchema
+  }, async (request) => ({
+    method: "POST",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "postRoute");
+
+// src/routes/http-methods/delete.ts
+var deleteSchema = {
+  description: "Handles a DELETE request and returns request information",
+  tags: [
+    "HTTP Methods"
+  ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the DELETE request"
+  },
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+var deleteRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.delete("/delete", {
+    schema: deleteSchema
+  }, async (request) => ({
+    method: "DELETE",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "deleteRoute");
+
+// src/routes/http-methods/put.ts
+var putSchema = {
+  description: "Handles a PUT request and returns request information",
+  tags: [
+    "HTTP Methods"
+  ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the PUT request"
+  },
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+var putRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.put("/put", {
+    schema: putSchema
+  }, async (request) => ({
+    method: "PUT",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "putRoute");
+
+// src/routes/http-methods/patch.ts
+var patchSchema = {
+  description: "Handles a PATCH request and returns request information",
+  tags: [
+    "HTTP Methods"
+  ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the PATCH request"
+  },
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+var patchRoute = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.patch("/patch", {
+    schema: patchSchema
+  }, async (request) => ({
+    method: "PATCH",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "patchRoute");
+
+// src/routes/status-codes/index.ts
+import { randomInt } from "node:crypto";
+var statusCodes = [
+  {
+    code: 100,
+    message: "Continue"
+  },
+  {
+    code: 101,
+    message: "Switching Protocols"
+  },
+  {
+    code: 102,
+    message: "Processing"
+  },
+  {
+    code: 103,
+    message: "Early Hints"
+  },
+  {
+    code: 200,
+    message: "OK"
+  },
+  {
+    code: 201,
+    message: "Created"
+  },
+  {
+    code: 202,
+    message: "Accepted"
+  },
+  {
+    code: 203,
+    message: "Non-Authoritative Information"
+  },
+  {
+    code: 204,
+    message: "No Content"
+  },
+  {
+    code: 205,
+    message: "Reset Content"
+  },
+  {
+    code: 206,
+    message: "Partial Content"
+  },
+  {
+    code: 207,
+    message: "Multi-Status"
+  },
+  {
+    code: 208,
+    message: "Already Reported"
+  },
+  {
+    code: 226,
+    message: "IM Used"
+  },
+  {
+    code: 300,
+    message: "Multiple Choices"
+  },
+  {
+    code: 301,
+    message: "Moved Permanently"
+  },
+  {
+    code: 302,
+    message: "Found"
+  },
+  {
+    code: 303,
+    message: "See Other"
+  },
+  {
+    code: 304,
+    message: "Not Modified"
+  },
+  {
+    code: 305,
+    message: "Use Proxy"
+  },
+  {
+    code: 306,
+    message: "Switch Proxy"
+  },
+  {
+    code: 307,
+    message: "Temporary Redirect"
+  },
+  {
+    code: 308,
+    message: "Permanent Redirect"
+  },
+  {
+    code: 400,
+    message: "Bad Request"
+  },
+  {
+    code: 401,
+    message: "Unauthorized"
+  },
+  {
+    code: 402,
+    message: "Payment Required"
+  },
+  {
+    code: 403,
+    message: "Forbidden"
+  },
+  {
+    code: 404,
+    message: "Not Found"
+  },
+  {
+    code: 405,
+    message: "Method Not Allowed"
+  },
+  {
+    code: 406,
+    message: "Not Acceptable"
+  },
+  {
+    code: 407,
+    message: "Proxy Authentication Required"
+  },
+  {
+    code: 408,
+    message: "Request Timeout"
+  },
+  {
+    code: 409,
+    message: "Conflict"
+  },
+  {
+    code: 410,
+    message: "Gone"
+  },
+  {
+    code: 411,
+    message: "Length Required"
+  },
+  {
+    code: 412,
+    message: "Precondition Failed"
+  },
+  {
+    code: 413,
+    message: "Payload Too Large"
+  },
+  {
+    code: 414,
+    message: "URI Too Long"
+  },
+  {
+    code: 415,
+    message: "Unsupported Media Type"
+  },
+  {
+    code: 416,
+    message: "Range Not Satisfiable"
+  },
+  {
+    code: 417,
+    message: "Expectation Failed"
+  },
+  {
+    code: 418,
+    message: "I'm a teapot"
+  },
+  {
+    code: 421,
+    message: "Misdirected Request"
+  },
+  {
+    code: 422,
+    message: "Unprocessable Entity"
+  },
+  {
+    code: 423,
+    message: "Locked"
+  },
+  {
+    code: 424,
+    message: "Failed Dependency"
+  },
+  {
+    code: 425,
+    message: "Too Early"
+  },
+  {
+    code: 426,
+    message: "Upgrade Required"
+  },
+  {
+    code: 428,
+    message: "Precondition Required"
+  },
+  {
+    code: 429,
+    message: "Too Many Requests"
+  },
+  {
+    code: 431,
+    message: "Request Header Fields Too Large"
+  },
+  {
+    code: 451,
+    message: "Unavailable For Legal Reasons"
+  },
+  {
+    code: 500,
+    message: "Internal Server Error"
+  },
+  {
+    code: 501,
+    message: "Not Implemented"
+  },
+  {
+    code: 502,
+    message: "Bad Gateway"
+  },
+  {
+    code: 503,
+    message: "Service Unavailable"
+  },
+  {
+    code: 504,
+    message: "Gateway Timeout"
+  },
+  {
+    code: 505,
+    message: "HTTP Version Not Supported"
+  },
+  {
+    code: 506,
+    message: "Variant Also Negotiates"
+  },
+  {
+    code: 507,
+    message: "Insufficient Storage"
+  },
+  {
+    code: 508,
+    message: "Loop Detected"
+  },
+  {
+    code: 510,
+    message: "Not Extended"
+  },
+  {
+    code: 511,
+    message: "Network Authentication Required"
+  }
+];
+var statusSchema = {
+  description: "Return status code or random status code if more than one are given ",
+  tags: [
+    "Status Codes"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "HTTP status code to be returned"
+      }
+    }
+  },
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+var statusCodeRoute = /* @__PURE__ */ __name((fastify2) => {
+  const handler = /* @__PURE__ */ __name(async (request, reply) => {
+    let { code } = request.params;
+    if (!code || !statusCodes.map((status) => status.code).includes(Number(code))) {
+      code = statusCodes[randomInt(0, statusCodes.length)].code.toString();
+    }
+    await reply.code(Number(code)).send({
+      status: `Response with status code ${code}`
+    });
+  }, "handler");
+  fastify2.get("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify2.post("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify2.put("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify2.patch("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify2.delete("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+}, "statusCodeRoute");
+
+// src/routes/response-inspection/cache.ts
+var cacheGetSchema = {
+  description: "Handles cache validation and retrieval.",
+  tags: [
+    "Response Inspection"
+  ],
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "string",
+      description: "The cached content or resource."
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
+    }
+  }
+};
+var cacheSetSchema = {
+  description: "Sets a Cache-Control header for n seconds.",
+  tags: [
+    "Response Inspection"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      value: {
+        type: "integer",
+        description: "Number of seconds to cache the resource."
+      }
+    },
+    required: [
+      "value"
+    ]
+  },
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "string",
+      description: "Confirmation message for setting cache."
+    }
+  }
+};
+var cacheRoutes = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/cache", {
+    schema: cacheGetSchema
+  }, async (request, reply) => {
+    const ifModifiedSince = request.headers["if-modified-since"];
+    const ifNoneMatch = request.headers["if-none-match"];
+    if (ifModifiedSince ?? ifNoneMatch) {
+      await reply.status(304).send();
+      return;
+    }
+    await reply.send("Cache content or resource response here.");
+  });
+  fastify2.get("/cache/:value", {
+    schema: cacheSetSchema
+  }, async (request, reply) => {
+    const { value } = request.params;
+    await reply.header("Cache-Control", `max-age=${value}`).send(`Cache-Control set for ${value} seconds.`);
+  });
+}, "cacheRoutes");
+
+// src/routes/response-inspection/etag.ts
+var etagSchema = {
+  description: "Handles ETag-based conditional requests.",
+  tags: [
+    "Response Inspection"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      etag: {
+        type: "string",
+        description: "The ETag value for the resource."
+      }
+    },
+    required: [
+      "etag"
+    ]
+  },
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "string",
+      description: "Resource content for matching ETag."
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    412: {
+      type: "null",
+      description: "Indicates a precondition failed due to mismatched ETag."
+    }
+  }
+};
+var etagRoutes = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/etag/:etag", {
+    schema: etagSchema
+  }, async (request, reply) => {
+    const { etag } = request.params;
+    const ifNoneMatch = request.headers["if-none-match"];
+    const ifMatch = request.headers["if-match"];
+    if (ifNoneMatch === etag) {
+      await reply.status(304).send();
+      return;
+    }
+    if (ifMatch && ifMatch !== etag) {
+      await reply.status(412).send();
+      return;
+    }
+    await reply.header("ETag", etag).send("Resource content for matching ETag.");
+  });
+}, "etagRoutes");
+
+// src/routes/response-inspection/response-headers.ts
+import { escape } from "html-escaper";
+var responseHeadersSchema = {
+  description: "Returns a set of response headers based on the query string.",
+  tags: [
+    "Response Inspection"
+  ],
+  querystring: {
+    type: "object",
+    additionalProperties: true,
+    description: "Freeform query string parameters to be added as response headers."
+  },
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      additionalProperties: true,
+      description: "Response headers as per query string parameters."
+    }
+  }
+};
+var responseHeadersRoutes = /* @__PURE__ */ __name((fastify2) => {
+  fastify2.get("/response-headers", {
+    schema: responseHeadersSchema
+  }, async (request, reply) => {
+    const queryParameters = request.query;
+    for (const [key, value] of Object.entries(queryParameters)) {
+      reply.header(key, escape(value));
+    }
+    const cleanedResponse = Object.fromEntries(Object.entries(queryParameters).map(([key, value]) => [
+      key,
+      escape(value)
+    ]));
+    await reply.send(cleanedResponse);
+  });
+  fastify2.post("/response-headers", {
+    schema: responseHeadersSchema
+  }, async (request, reply) => {
+    const queryParameters = request.query ?? {};
+    const body = request.body ?? {};
+    for (const [key, value] of Object.entries(queryParameters)) {
+      reply.header(key, escape(value));
+    }
+    for (const [key, value] of Object.entries(body)) {
+      reply.header(key, escape(value));
+    }
+    const cleanedResponse = Object.fromEntries(Object.entries({
+      ...queryParameters,
+      ...body
+    }).map(([key, value]) => [
+      key,
+      escape(value)
+    ]));
+    await reply.send(cleanedResponse);
+  });
+}, "responseHeadersRoutes");
+
+// src/index.ts
+var fastify = Fastify(fastifyConfig);
 await fastify.register(fastifyStatic, {
-    root: path.resolve('./public'),
+  root: path.resolve("./node_modules/@scalar/api-reference/dist"),
+  prefix: "/scalar"
 });
-// Set up Swagger for API documentation
+await fastify.register(fastifyStatic, {
+  root: path.resolve("./public"),
+  decorateReply: false
+});
+await fastify.register(fastifyHelmet);
 await fastify.register(fastifySwagger, fastifySwaggerConfig);
-// Register Swagger UI
 await registerSwaggerUi(fastify);
-// Register the index / home page route
 await fastify.register(indexRoute);
-// Register the HTTP method routes
 await fastify.register(getRoute);
 await fastify.register(postRoute);
 await fastify.register(deleteRoute);
 await fastify.register(putRoute);
 await fastify.register(patchRoute);
-// Register the request inspection routes
+await fastify.register(statusCodeRoute);
 await fastify.register(ipRoute);
 await fastify.register(headersRoute);
 await fastify.register(userAgentRoute);
-// Register the status code routes
-await fastify.register(statusCodeRoute);
-// Start the Fastify server
-export const start = async () => {
-    try {
-        await fastify.listen({ port: 3000, host: '127.0.0.1' });
-        fastify.log.info('Server is running at http://localhost:3000');
+await fastify.register(cacheRoutes);
+await fastify.register(etagRoutes);
+await fastify.register(responseHeadersRoutes);
+var start = /* @__PURE__ */ __name(async () => {
+  try {
+    let port = 3e3;
+    if (process.env.PORT) {
+      port = Number.parseInt(process.env.PORT, 10);
     }
-    catch (error) {
-        /* c8 ignore next 4 */
-        fastify.log.error(error);
-        // eslint-disable-next-line unicorn/no-process-exit
-        process.exit(1);
+    let host = "0.0.0.0";
+    if (process.env.HOST) {
+      host = process.env.HOST;
     }
-};
+    await fastify.listen({
+      port,
+      host
+    });
+  } catch (error) {
+    fastify.log.error(error);
+    process.exit(1);
+  }
+}, "start");
 await start();
+export {
+  start
+};