@apicircle/mock-server-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1078 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildRouter: () => buildRouter,
+  createMockApp: () => createMockApp,
+  getFreePort: () => getFreePort,
+  isPortFree: () => isPortFree,
+  openApiPathToHono: () => openApiPathToHono,
+  parseInsomniaToEndpoints: () => parseInsomniaToEndpoints,
+  parseOpenApiToEndpoints: () => parseOpenApiToEndpoints,
+  parsePostmanToEndpoints: () => parsePostmanToEndpoints,
+  parseSourceToEndpoints: () => parseSourceToEndpoints,
+  schemaToExample: () => schemaToExample,
+  startMockServer: () => startMockServer,
+  stopMockServer: () => stopMockServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parsers/openapi.ts
+var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"), 1);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+
+// src/faker/schemaToExample.ts
+var FORMAT_DEFAULTS = {
+  "date-time": "2026-04-27T00:00:00.000Z",
+  date: "2026-04-27",
+  time: "00:00:00",
+  email: "user@example.com",
+  hostname: "example.com",
+  ipv4: "127.0.0.1",
+  ipv6: "::1",
+  uri: "https://example.com",
+  url: "https://example.com",
+  uuid: "00000000-0000-4000-8000-000000000000",
+  byte: "AA==",
+  binary: ""
+};
+function schemaToExample(schema) {
+  if (!schema) return null;
+  if (schema.example !== void 0) return schema.example;
+  if (schema.default !== void 0) return schema.default;
+  if (schema.const !== void 0) return schema.const;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return schema.enum[0];
+  }
+  const branch = schema.allOf?.[0] ?? schema.oneOf?.[0] ?? schema.anyOf?.[0];
+  if (branch) return schemaToExample(branch);
+  const type = pickType(schema.type);
+  switch (type) {
+    case "string":
+      return schema.format ? FORMAT_DEFAULTS[schema.format] ?? "string" : "string";
+    case "integer":
+      return 0;
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "null":
+      return null;
+    case "array": {
+      const items = schema.items ? schemaToExample(schema.items) : null;
+      return [items];
+    }
+    case "object":
+    default: {
+      const properties = schema.properties ?? {};
+      const required = schema.required ?? Object.keys(properties);
+      const out = {};
+      for (const key of required) {
+        const propSchema = properties[key];
+        out[key] = schemaToExample(propSchema);
+      }
+      return out;
+    }
+  }
+}
+function pickType(type) {
+  if (!type) return void 0;
+  if (typeof type === "string") return type;
+  return type.find((t) => t !== "null") ?? type[0];
+}
+
+// src/parsers/buildEndpoint.ts
+function bodyTypeForContentType(contentType) {
+  if (!contentType) return "json";
+  const main = contentType.toLowerCase().split(";")[0]?.trim() ?? "";
+  if (main.includes("json")) return "json";
+  if (main.includes("xml")) return "xml";
+  if (main === "application/x-www-form-urlencoded") return "urlencoded";
+  if (main === "multipart/form-data") return "form-data";
+  if (main === "application/octet-stream") return "binary";
+  if (main.startsWith("text/")) return "text";
+  return "text";
+}
+function bodyFromString(content, type) {
+  switch (type) {
+    case "none":
+      return { type: "none", content: "" };
+    case "binary":
+      return { type: "binary", content: "" };
+    case "form-data":
+      return { type: "form-data", content: "", formRows: [] };
+    default:
+      return { type, content };
+  }
+}
+function buildMockResponse(parsed) {
+  const contentType = parsed.headers.find((h) => h.key.toLowerCase() === "content-type")?.value;
+  const bodyType = bodyTypeForContentType(contentType);
+  return {
+    status: parsed.status,
+    headers: parsed.headers.map((h) => ({ ...h, enabled: true })),
+    body: bodyFromString(parsed.body, bodyType),
+    ...parsed.delayMs !== void 0 ? { delayMs: parsed.delayMs } : {}
+  };
+}
+function buildMockEndpoint(input) {
+  return {
+    id: input.id,
+    name: input.name ?? `${input.method} ${input.pathPattern}`,
+    method: input.method,
+    pathPattern: input.pathPattern,
+    description: input.description,
+    requestSchema: { pathParams: [], queryParams: [], headers: [], cookies: [] },
+    requestValidation: [],
+    responseRules: [],
+    defaultResponse: buildMockResponse(input.response),
+    example: input.example
+  };
+}
+
+// src/parsers/openapi.ts
+var SUPPORTED_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+async function parseOpenApiToEndpoints(source, format = "json", opts = {}) {
+  const warnings = [];
+  const raw = format === "yaml" ? safeYamlLoad(source) : safeJsonParse(source);
+  if (!raw || typeof raw !== "object") {
+    return { endpoints: [], warnings: ["Could not parse OpenAPI source"] };
+  }
+  let api;
+  try {
+    const dereffed = await import_swagger_parser.default.dereference(raw);
+    api = dereffed;
+  } catch (err) {
+    warnings.push(
+      `swagger-parser failed: ${err instanceof Error ? err.message : "unknown error"}; falling back to raw spec`
+    );
+    api = raw;
+  }
+  const paths = api.paths ?? {};
+  const endpoints = [];
+  let endpointId = 0;
+  for (const [path, ops] of Object.entries(paths)) {
+    if (!ops || typeof ops !== "object") continue;
+    for (const method of Object.keys(ops)) {
+      const upper = method.toUpperCase();
+      if (!SUPPORTED_METHODS.includes(upper)) continue;
+      const op = ops[method];
+      if (!op || typeof op !== "object") continue;
+      const built = buildEndpointFromOp(path, upper, op, opts, warnings, endpointId++);
+      if (built) endpoints.push(built);
+    }
+  }
+  return { endpoints, warnings };
+}
+function buildEndpointFromOp(path, method, op, opts, warnings, index) {
+  const responses = op.responses ?? {};
+  const candidates = Object.keys(responses).filter((code) => /^2\d\d$/.test(code)).map((code) => Number(code));
+  if (candidates.length === 0) {
+    warnings.push(`No 2xx response defined for ${method} ${path} \u2014 skipping`);
+    return null;
+  }
+  const status = opts.preferStatus ? candidates.includes(opts.preferStatus) ? opts.preferStatus : Math.min(...candidates) : Math.min(...candidates);
+  const response = responses[String(status)];
+  if (!response) {
+    warnings.push(`Response ${status} missing for ${method} ${path}`);
+    return null;
+  }
+  const { contentType, body, exampleName } = pickResponsePayload(response, op);
+  const headers = pickResponseHeaders(response, contentType);
+  return buildMockEndpoint({
+    id: `op-${index}-${method.toLowerCase()}-${slug(path)}`,
+    method,
+    pathPattern: path,
+    example: exampleName,
+    response: { status, headers, body }
+  });
+}
+function pickResponsePayload(response, op) {
+  if (response.content) {
+    const mediaTypes = Object.keys(response.content);
+    const preferred = mediaTypes.find((m) => m.toLowerCase().includes("json")) ?? mediaTypes[0] ?? "application/json";
+    const entry = response.content[preferred];
+    if (entry) {
+      if (entry.example !== void 0) {
+        return {
+          contentType: preferred,
+          body: stringifyForContentType(entry.example, preferred),
+          exampleName: void 0
+        };
+      }
+      if (entry.examples) {
+        const firstExampleName = Object.keys(entry.examples)[0];
+        if (firstExampleName) {
+          const v = entry.examples[firstExampleName];
+          return {
+            contentType: preferred,
+            body: stringifyForContentType(v?.value, preferred),
+            exampleName: firstExampleName
+          };
+        }
+      }
+      if (entry.schema) {
+        return {
+          contentType: preferred,
+          body: stringifyForContentType(schemaToExample(entry.schema), preferred),
+          exampleName: void 0
+        };
+      }
+    }
+  }
+  if (response.schema) {
+    const ct = (op.produces && op.produces[0]) ?? "application/json";
+    return {
+      contentType: ct,
+      body: stringifyForContentType(schemaToExample(response.schema), ct),
+      exampleName: void 0
+    };
+  }
+  if (response.examples) {
+    const firstName = Object.keys(response.examples)[0];
+    if (firstName) {
+      const v = response.examples[firstName];
+      return {
+        contentType: firstName,
+        body: stringifyForContentType(v, firstName),
+        exampleName: firstName
+      };
+    }
+  }
+  return {
+    contentType: "application/json",
+    body: "{}",
+    exampleName: void 0
+  };
+}
+function pickResponseHeaders(response, contentType) {
+  const headers = [{ key: "Content-Type", value: contentType }];
+  if (response.headers) {
+    for (const [name, def] of Object.entries(response.headers)) {
+      if (name.toLowerCase() === "content-type") continue;
+      const value = def.example !== void 0 ? def.example : schemaToExample(def.schema);
+      if (value === void 0 || value === null) continue;
+      const text = typeof value === "string" ? value : JSON.stringify(value);
+      headers.push({ key: name, value: text });
+    }
+  }
+  return headers;
+}
+function stringifyForContentType(value, contentType) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (contentType.toLowerCase().includes("json")) {
+    return JSON.stringify(value, null, 2);
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function slug(s) {
+  return s.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "root";
+}
+function safeJsonParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+function safeYamlLoad(s) {
+  try {
+    return import_js_yaml.default.load(s);
+  } catch {
+    return safeJsonParse(s);
+  }
+}
+
+// src/parsers/postman.ts
+var SUPPORTED_METHODS2 = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+function parsePostmanToEndpoints(source) {
+  const warnings = [];
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    return { endpoints: [], warnings: ["Could not parse Postman collection JSON"] };
+  }
+  const endpoints = [];
+  let endpointId = 0;
+  walkItems(parsed.item ?? [], (item) => {
+    if (!item.request) return;
+    const method = (item.request.method ?? "GET").toUpperCase();
+    if (!SUPPORTED_METHODS2.includes(method)) {
+      warnings.push(`Skipping ${method} (unsupported method): ${item.name ?? "(unnamed)"}`);
+      return;
+    }
+    const path = extractPath(item.request.url);
+    if (!path) {
+      warnings.push(`Skipping request with no extractable path: ${item.name ?? "(unnamed)"}`);
+      return;
+    }
+    const example = item.response?.[0];
+    if (example) {
+      endpoints.push(
+        buildMockEndpoint({
+          id: `pm-${endpointId++}-${slug2(path)}`,
+          name: item.name,
+          method,
+          pathPattern: path,
+          example: example.name,
+          response: {
+            // Postman's `code` is the canonical numeric status; `status` is a
+            // human-readable label that *sometimes* parses as a number. Try
+            // both, fall back to 200 only when neither yields a finite number.
+            status: example.code ?? (Number.isFinite(Number(example.status)) ? Number(example.status) : 200),
+            headers: (example.header ?? []).map((h) => ({ key: h.key, value: h.value })),
+            body: example.body ?? ""
+          }
+        })
+      );
+    } else {
+      endpoints.push(
+        buildMockEndpoint({
+          id: `pm-${endpointId++}-${slug2(path)}`,
+          name: item.name,
+          method,
+          pathPattern: path,
+          response: {
+            status: 200,
+            headers: [{ key: "Content-Type", value: "application/json" }],
+            body: "{}"
+          }
+        })
+      );
+    }
+  });
+  return { endpoints, warnings };
+}
+function walkItems(items, visit) {
+  for (const item of items) {
+    if (item.item) walkItems(item.item, visit);
+    else if (item.request) visit(item);
+  }
+}
+function extractPath(url) {
+  if (!url) return null;
+  if (typeof url === "string") {
+    return urlToPath(url);
+  }
+  if (url.raw) return urlToPath(url.raw);
+  if (url.path) {
+    const segments = Array.isArray(url.path) ? url.path : [url.path];
+    return "/" + segments.filter(Boolean).join("/");
+  }
+  return null;
+}
+function urlToPath(raw) {
+  try {
+    const parsed = new URL(raw.replace(/^https?:\/\/[^/]*$/, raw + "/"));
+    return parsed.pathname || "/";
+  } catch {
+    const idx = raw.indexOf("/");
+    return idx === -1 ? "/" : raw.slice(idx);
+  }
+}
+function slug2(s) {
+  return s.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "root";
+}
+
+// src/parsers/insomnia.ts
+var SUPPORTED_METHODS3 = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+function parseInsomniaToEndpoints(source) {
+  const warnings = [];
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    return { endpoints: [], warnings: ["Could not parse Insomnia export JSON"] };
+  }
+  const endpoints = [];
+  let endpointId = 0;
+  for (const r of parsed.resources ?? []) {
+    if (r._type !== "request") continue;
+    const method = (r.method ?? "GET").toUpperCase();
+    if (!SUPPORTED_METHODS3.includes(method)) {
+      warnings.push(`Skipping ${method} (unsupported method): ${r.name ?? "(unnamed)"}`);
+      continue;
+    }
+    const path = extractPath2(r.url);
+    if (!path) {
+      warnings.push(`Skipping request with no path: ${r.name ?? "(unnamed)"}`);
+      continue;
+    }
+    endpoints.push(
+      buildMockEndpoint({
+        id: `ins-${endpointId++}-${slug3(path)}`,
+        name: r.name,
+        method,
+        pathPattern: path,
+        response: {
+          status: 200,
+          headers: [{ key: "Content-Type", value: "application/json" }],
+          body: "{}"
+        }
+      })
+    );
+  }
+  return { endpoints, warnings };
+}
+function extractPath2(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).pathname || "/";
+  } catch {
+    const idx = url.indexOf("/");
+    return idx === -1 ? "/" : url.slice(idx);
+  }
+}
+function slug3(s) {
+  return s.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "root";
+}
+
+// src/handlers/buildRouter.ts
+var import_hono = require("hono");
+
+// src/cors.ts
+var import_cors = require("hono/cors");
+function buildCors(config) {
+  if (!config.enabled) return null;
+  if (config.origins.length === 0) return null;
+  return (0, import_cors.cors)({
+    origin: config.origins,
+    allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+    allowHeaders: ["Content-Type", "Authorization", "Accept", "X-Requested-With"],
+    exposeHeaders: ["Content-Type"],
+    credentials: false,
+    maxAge: 600
+  });
+}
+
+// src/validation/evaluate.ts
+function evaluateValidation(endpoint, ctx) {
+  for (const rule of endpoint.requestValidation) {
+    if (!rule.enabled) continue;
+    if (!rulePasses(rule, ctx)) {
+      return rule.failResponse;
+    }
+  }
+  return null;
+}
+function rulePasses(rule, ctx) {
+  switch (rule.kind) {
+    case "header-required": {
+      const v = ctx.headers[rule.target.toLowerCase()];
+      return v !== void 0 && v !== "";
+    }
+    case "header-equals": {
+      const v = ctx.headers[rule.target.toLowerCase()];
+      return v !== void 0 && v === (rule.expected ?? "");
+    }
+    case "header-matches": {
+      const v = ctx.headers[rule.target.toLowerCase()];
+      if (v === void 0) return false;
+      return safeRegexTest(rule.expected, v);
+    }
+    case "query-required": {
+      const v = ctx.query[rule.target];
+      return v !== void 0 && v !== "";
+    }
+    case "query-equals": {
+      const v = ctx.query[rule.target];
+      return v !== void 0 && v === (rule.expected ?? "");
+    }
+    case "query-matches": {
+      const v = ctx.query[rule.target];
+      if (v === void 0) return false;
+      return safeRegexTest(rule.expected, v);
+    }
+    case "cookie-required": {
+      const v = ctx.cookies[rule.target];
+      return v !== void 0 && v !== "";
+    }
+    case "body-required": {
+      if (ctx.bodyJson !== void 0 && ctx.bodyJson !== null) {
+        if (Array.isArray(ctx.bodyJson)) return ctx.bodyJson.length > 0;
+        if (typeof ctx.bodyJson === "object") {
+          return Object.keys(ctx.bodyJson).length > 0;
+        }
+        return true;
+      }
+      return ctx.bodyText.length > 0;
+    }
+    case "content-type-equals": {
+      const ct = ctx.headers["content-type"] ?? "";
+      const main = ct.split(";")[0]?.trim().toLowerCase() ?? "";
+      return main === (rule.expected ?? "").trim().toLowerCase();
+    }
+  }
+}
+function safeRegexTest(pattern, value) {
+  if (pattern === void 0) return false;
+  try {
+    const m = /^\/(.*)\/([a-z]*)$/.exec(pattern);
+    const re = m ? new RegExp(m[1], m[2]) : new RegExp(pattern);
+    return re.test(value);
+  } catch {
+    return false;
+  }
+}
+
+// src/rules/evaluate.ts
+function evaluateResponseRules(endpoint, ctx) {
+  for (const rule of endpoint.responseRules) {
+    if (!rule.enabled) continue;
+    if (rule.when.length === 0) continue;
+    if (rule.when.every((clause) => matchesClause(clause, ctx))) {
+      return rule.response;
+    }
+  }
+  return endpoint.defaultResponse;
+}
+function matchesClause(clause, ctx) {
+  const actual = readScopeValue(clause.scope, clause.target, ctx);
+  return applyOp(clause.op, actual, clause.value);
+}
+function readScopeValue(scope, target, ctx) {
+  switch (scope) {
+    case "query":
+      return ctx.query[target];
+    case "pathParam":
+      return ctx.pathParams[target];
+    case "header":
+      return ctx.headers[target.toLowerCase()];
+    case "cookie":
+      return ctx.cookies[target];
+    case "body-json-path":
+      return resolveJsonPathString(ctx.bodyJson, target);
+  }
+}
+function applyOp(op, actual, expected) {
+  switch (op) {
+    case "present":
+      return actual !== void 0 && actual !== "";
+    case "absent":
+      return actual === void 0 || actual === "";
+    case "equals":
+      return actual !== void 0 && expected !== void 0 && actual === expected;
+    case "not-equals":
+      return actual === void 0 || expected === void 0 || actual !== expected;
+    case "matches": {
+      if (actual === void 0 || expected === void 0) return false;
+      try {
+        const re = compileMaybeFlaggedRegex(expected);
+        return re.test(actual);
+      } catch {
+        return false;
+      }
+    }
+    case "gt":
+    case "lt":
+    case "gte":
+    case "lte": {
+      if (actual === void 0 || expected === void 0) return false;
+      const a = Number(actual);
+      const e = Number(expected);
+      if (!Number.isFinite(a) || !Number.isFinite(e)) return false;
+      switch (op) {
+        case "gt":
+          return a > e;
+        case "lt":
+          return a < e;
+        case "gte":
+          return a >= e;
+        case "lte":
+          return a <= e;
+      }
+    }
+  }
+}
+function compileMaybeFlaggedRegex(input) {
+  const m = /^\/(.*)\/([a-z]*)$/.exec(input);
+  if (m) return new RegExp(m[1], m[2]);
+  return new RegExp(input);
+}
+function resolveJsonPathString(body, jsonPath) {
+  const value = resolveJsonPath(body, jsonPath);
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function resolveJsonPath(body, jsonPath) {
+  if (body === void 0 || body === null) return void 0;
+  let path = jsonPath.trim();
+  if (path.startsWith("$")) path = path.slice(1);
+  if (path.startsWith(".")) path = path.slice(1);
+  if (path === "") return body;
+  let cursor = body;
+  const re = /([^.[\]]+)|\[([^\]]+)\]/g;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    if (cursor === void 0 || cursor === null) return void 0;
+    const key = match[1] ?? match[2];
+    if (key === void 0) return void 0;
+    if (Array.isArray(cursor)) {
+      const idx = Number(key);
+      if (!Number.isInteger(idx)) return void 0;
+      cursor = cursor[idx];
+      continue;
+    }
+    if (typeof cursor === "object") {
+      cursor = cursor[key];
+      continue;
+    }
+    return void 0;
+  }
+  return cursor;
+}
+
+// src/response/applyMultipliers.ts
+function applyMultipliers(response, ctx) {
+  const multipliers = response.multipliers;
+  if (!multipliers || multipliers.length === 0) return response;
+  if (response.body.type !== "json") return response;
+  let parsed;
+  try {
+    parsed = JSON.parse(response.body.content);
+  } catch {
+    return response;
+  }
+  let mutated = false;
+  for (const multiplier of multipliers) {
+    const count = resolveCount(multiplier, ctx);
+    if (count === null) continue;
+    const next = applyOneMultiplier(parsed, multiplier.targetJsonPath, count);
+    if (next.changed) {
+      parsed = next.value;
+      mutated = true;
+    }
+  }
+  if (!mutated) return response;
+  return {
+    ...response,
+    body: { type: "json", content: JSON.stringify(parsed) }
+  };
+}
+function resolveCount(multiplier, ctx) {
+  const raw = readSource(multiplier, ctx);
+  let count;
+  if (raw === void 0 || raw === "" || raw === null) {
+    count = multiplier.defaultCount;
+  } else {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+      count = multiplier.defaultCount;
+    } else {
+      count = Math.trunc(parsed);
+    }
+  }
+  if (multiplier.min !== void 0 && count < multiplier.min) count = multiplier.min;
+  if (multiplier.max !== void 0 && count > multiplier.max) count = multiplier.max;
+  if (count < 0) count = 0;
+  return count;
+}
+function readSource(multiplier, ctx) {
+  const { kind, key } = multiplier.source;
+  switch (kind) {
+    case "query":
+      return ctx.query[key];
+    case "pathParam":
+      return ctx.pathParams[key];
+    case "header":
+      return ctx.headers[key.toLowerCase()];
+    case "body-json-path":
+      return resolveJsonPath(ctx.bodyJson, key);
+  }
+}
+function applyOneMultiplier(body, jsonPath, count) {
+  const segments = parsePathSegments(jsonPath);
+  if (segments.length === 0) {
+    if (Array.isArray(body) && body.length > 0) {
+      return { changed: true, value: repeatArray(body, count) };
+    }
+    return { changed: false, value: body };
+  }
+  return setAtPath(body, segments, 0, count);
+}
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function parsePathSegments(jsonPath) {
+  let path = jsonPath.trim();
+  if (path.startsWith("$")) path = path.slice(1);
+  if (path.startsWith(".")) path = path.slice(1);
+  if (path === "") return [];
+  const out = [];
+  const re = /([^.[\]]+)|\[([^\]]+)\]/g;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    if (match[1] !== void 0) {
+      if (FORBIDDEN_KEYS.has(match[1])) return [];
+      out.push({ kind: "key", name: match[1] });
+    } else if (match[2] !== void 0) {
+      const n = Number(match[2]);
+      if (Number.isInteger(n)) {
+        out.push({ kind: "index", idx: n });
+      } else {
+        if (FORBIDDEN_KEYS.has(match[2])) return [];
+        out.push({ kind: "key", name: match[2] });
+      }
+    }
+  }
+  return out;
+}
+function setAtPath(cursor, segments, depth, count) {
+  if (depth === segments.length) {
+    if (Array.isArray(cursor) && cursor.length > 0) {
+      return { changed: true, value: repeatArray(cursor, count) };
+    }
+    return { changed: false, value: cursor };
+  }
+  const seg = segments[depth];
+  if (seg.kind === "index") {
+    if (!Array.isArray(cursor)) return { changed: false, value: cursor };
+    if (seg.idx < 0 || seg.idx >= cursor.length) return { changed: false, value: cursor };
+    const inner2 = setAtPath(cursor[seg.idx], segments, depth + 1, count);
+    if (!inner2.changed) return { changed: false, value: cursor };
+    const next = cursor.slice();
+    next[seg.idx] = inner2.value;
+    return { changed: true, value: next };
+  }
+  if (cursor === null || typeof cursor !== "object" || Array.isArray(cursor)) {
+    return { changed: false, value: cursor };
+  }
+  const obj = cursor;
+  if (!(seg.name in obj)) return { changed: false, value: cursor };
+  const inner = setAtPath(obj[seg.name], segments, depth + 1, count);
+  if (!inner.changed) return { changed: false, value: cursor };
+  return { changed: true, value: { ...obj, [seg.name]: inner.value } };
+}
+function repeatArray(arr, count) {
+  if (count <= 0) return [];
+  const template = arr[0];
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    out.push(cloneShallow(template));
+  }
+  return out;
+}
+function cloneShallow(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.slice();
+  return { ...value };
+}
+
+// src/handlers/buildRouter.ts
+function buildRouter(server, opts = {}) {
+  const app = new import_hono.Hono();
+  const corsMiddleware = buildCors(server.cors);
+  if (corsMiddleware) app.use("*", corsMiddleware);
+  const sorted = [...server.endpoints].sort((a, b) => {
+    const aHasParam = /\{/.test(a.pathPattern);
+    const bHasParam = /\{/.test(b.pathPattern);
+    if (aHasParam !== bHasParam) return aHasParam ? 1 : -1;
+    return b.pathPattern.length - a.pathPattern.length;
+  });
+  for (const endpoint of sorted) {
+    const honoPath = openApiPathToHono(endpoint.pathPattern);
+    const handler = makeHandler(endpoint, opts);
+    switch (endpoint.method) {
+      case "GET":
+        app.get(honoPath, handler);
+        break;
+      case "POST":
+        app.post(honoPath, handler);
+        break;
+      case "PUT":
+        app.put(honoPath, handler);
+        break;
+      case "PATCH":
+        app.patch(honoPath, handler);
+        break;
+      case "DELETE":
+        app.delete(honoPath, handler);
+        break;
+      case "HEAD":
+      case "OPTIONS":
+        app.on(endpoint.method, honoPath, handler);
+        break;
+    }
+  }
+  app.notFound(
+    (c) => c.json(
+      {
+        error: "No mock endpoint matches this path",
+        method: c.req.method,
+        path: new URL(c.req.url).pathname
+      },
+      404
+    )
+  );
+  return app;
+}
+function makeHandler(endpoint, opts) {
+  return async (c) => {
+    opts.onRequest?.({
+      endpointId: endpoint.id,
+      method: endpoint.method,
+      path: endpoint.pathPattern
+    });
+    const ctx = await buildRequestContext(c);
+    const failResponse = evaluateValidation(endpoint, ctx);
+    if (failResponse) {
+      return await respond(c, failResponse, ctx);
+    }
+    const matched = evaluateResponseRules(endpoint, ctx);
+    return await respond(c, matched, ctx);
+  };
+}
+async function buildRequestContext(c) {
+  const url = new URL(c.req.url);
+  const queryEntries = Array.from(url.searchParams.entries());
+  const query = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of queryEntries) {
+    if (!(k in query)) query[k] = v;
+  }
+  const headers = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of c.req.raw.headers.entries()) {
+    headers[k.toLowerCase()] = v;
+  }
+  const honoParams = c.req.param();
+  const pathParams = /* @__PURE__ */ Object.create(null);
+  for (const k of Object.keys(honoParams)) {
+    pathParams[k] = honoParams[k];
+  }
+  const cookies = parseCookieHeader(headers["cookie"]);
+  let bodyJson = void 0;
+  let bodyText = "";
+  const ct = headers["content-type"] ?? "";
+  if (ct.toLowerCase().includes("json")) {
+    try {
+      bodyText = await c.req.text();
+      bodyJson = bodyText ? JSON.parse(bodyText) : void 0;
+    } catch {
+    }
+  } else {
+    try {
+      bodyText = await c.req.text();
+    } catch {
+    }
+  }
+  return { query, pathParams, headers, cookies, bodyText, bodyJson };
+}
+function parseCookieHeader(cookieHeader) {
+  const out = /* @__PURE__ */ Object.create(null);
+  if (!cookieHeader) return out;
+  for (const part of cookieHeader.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const k = part.slice(0, eq).trim();
+    const v = part.slice(eq + 1).trim();
+    if (k && !(k in out)) out[k] = v;
+  }
+  return out;
+}
+async function respond(c, response, ctx) {
+  if (response.delayMs && response.delayMs > 0) {
+    await new Promise((resolve) => setTimeout(resolve, response.delayMs));
+  }
+  const finalResponse = applyMultipliers(response, ctx);
+  let userSetContentType = false;
+  for (const h of finalResponse.headers) {
+    if (!h.enabled) continue;
+    if (!h.key.trim()) continue;
+    if (h.key.toLowerCase() === "content-type") userSetContentType = true;
+    c.header(h.key, h.value);
+  }
+  const body = finalResponse.body;
+  if (!userSetContentType) {
+    const defaultCt = defaultContentTypeFor(body.type);
+    if (defaultCt) c.header("Content-Type", defaultCt);
+  }
+  c.header("X-Content-Type-Options", "nosniff");
+  if (body.type === "none") {
+    return c.body(null, finalResponse.status);
+  }
+  if (body.type === "binary" || body.type === "form-data") {
+    return c.body(null, finalResponse.status);
+  }
+  return c.body(body.content, finalResponse.status);
+}
+function defaultContentTypeFor(bodyType) {
+  switch (bodyType) {
+    case "json":
+      return "application/json; charset=utf-8";
+    case "text":
+      return "text/plain; charset=utf-8";
+    case "binary":
+      return "application/octet-stream";
+    case "form-data":
+      return "multipart/form-data";
+    case "none":
+    default:
+      return null;
+  }
+}
+function openApiPathToHono(path) {
+  return path.replace(/\{([^}]+)\}/g, ":$1");
+}
+
+// src/runtime/nodeAdapter.ts
+var import_node_server = require("@hono/node-server");
+
+// src/runtime/portFinder.ts
+var import_node_net = require("net");
+async function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = (0, import_node_net.createServer)();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, () => {
+      const address = server.address();
+      if (typeof address === "object" && address !== null) {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        server.close(() => reject(new Error("Could not determine free port")));
+      }
+    });
+  });
+}
+async function isPortFree(port) {
+  return new Promise((resolve) => {
+    const server = (0, import_node_net.createServer)();
+    server.unref();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port);
+  });
+}
+
+// src/runtime/nodeAdapter.ts
+async function serveOnNode(app, opts = {}) {
+  const port = opts.port && opts.port > 0 ? opts.port : await getFreePort();
+  const host = opts.host ?? "127.0.0.1";
+  let server = null;
+  await new Promise((resolve, reject) => {
+    try {
+      server = (0, import_node_server.serve)(
+        {
+          fetch: app.fetch,
+          port,
+          hostname: host
+        },
+        () => resolve()
+      );
+      server.on("error", reject);
+    } catch (err) {
+      reject(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  return {
+    port,
+    close: () => new Promise((resolve, reject) => {
+      if (!server) return resolve();
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    })
+  };
+}
+
+// src/index.ts
+async function parseSourceToEndpoints(source) {
+  switch (source.kind) {
+    case "openapi":
+      return parseOpenApiToEndpoints(source.spec, source.format);
+    case "postman":
+      return parsePostmanToEndpoints(source.collection);
+    case "insomnia":
+      return parseInsomniaToEndpoints(source.export);
+    case "manual":
+      return { endpoints: source.endpoints, warnings: [] };
+  }
+}
+function createMockApp(server, opts = {}) {
+  return buildRouter(server, opts);
+}
+async function startMockServer(server, opts = {}) {
+  const app = createMockApp(server, { onRequest: opts.onRequest });
+  const desired = {
+    host: opts.host,
+    port: opts.port ?? server.defaultPort ?? void 0
+  };
+  return serveOnNode(app, desired);
+}
+async function stopMockServer(handle) {
+  return handle.close();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRouter,
+  createMockApp,
+  getFreePort,
+  isPortFree,
+  openApiPathToHono,
+  parseInsomniaToEndpoints,
+  parseOpenApiToEndpoints,
+  parsePostmanToEndpoints,
+  parseSourceToEndpoints,
+  schemaToExample,
+  startMockServer,
+  stopMockServer
+});
+//# sourceMappingURL=index.cjs.map