@redocly/cli 2.39.0 → 2.41.0

package/lib/chunks/ER45DAHG.js

@@ -0,0 +1,492 @@
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+import {
+  isPlainObject
+} from "./YK6T7IHG.js";
+
+// src/commands/drift/utils/files.ts
+import { open, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+var SPEC_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
+async function listOpenApiFiles(rootDir) {
+  const output = [];
+  async function walk(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const absolutePath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (entry.isFile() && SPEC_FILE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+        output.push(absolutePath);
+      }
+    }
+  }
+  await walk(rootDir);
+  output.sort();
+  return output;
+}
+async function readProbe(filePath, maxBytes = 4096) {
+  const fileHandle = await open(filePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(maxBytes);
+    const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
+    return buffer.toString("utf8", 0, bytesRead);
+  } finally {
+    await fileHandle.close();
+  }
+}
+function normalizeFsPath(value) {
+  return path.resolve(process.cwd(), value);
+}
+async function listFilesRecursively(rootPath) {
+  const stats = await stat(rootPath);
+  if (stats.isFile()) {
+    return [rootPath];
+  }
+  if (!stats.isDirectory()) {
+    return [];
+  }
+  const output = [];
+  async function walk(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const absolutePath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        output.push(absolutePath);
+      }
+    }
+  }
+  await walk(rootPath);
+  output.sort();
+  return output;
+}
+
+// src/commands/drift/utils/http.ts
+var DUMMY_HOST = "drift.local";
+var DUMMY_BASE_URL = `http://${DUMMY_HOST}`;
+function isSyntheticHost(host) {
+  return host === DUMMY_HOST;
+}
+var IGNORED_UNDOCUMENTED_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-charset",
+  "accept-encoding",
+  "accept-language",
+  "authorization",
+  "baggage",
+  "cache-control",
+  "cdn-loop",
+  "cookie",
+  "connection",
+  "content-length",
+  "content-type",
+  "dpr",
+  "dnt",
+  "downlink",
+  "ect",
+  "forwarded",
+  "host",
+  "if-match",
+  "if-modified-since",
+  "if-none-match",
+  "if-range",
+  "if-unmodified-since",
+  "origin",
+  "pragma",
+  "priority",
+  "range",
+  "referer",
+  "sec-fetch-dest",
+  "sec-fetch-mode",
+  "sec-fetch-site",
+  "sec-fetch-user",
+  "sec-gpc",
+  "sentry-trace",
+  "te",
+  "traceparent",
+  "tracestate",
+  "upgrade",
+  "upgrade-insecure-requests",
+  "user-agent",
+  "via",
+  "x-amzn-trace-id",
+  "x-client-trace-id",
+  "x-cloud-trace-context",
+  "x-correlation-id",
+  "x-http-method-override",
+  "x-method-override",
+  "x-real-ip",
+  "x-request-id",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-port",
+  "x-forwarded-proto"
+]);
+var IGNORED_UNDOCUMENTED_HEADER_PREFIXES = [
+  "cf-",
+  "sec-ch-",
+  "sec-fetch-",
+  "x-b3-",
+  "x-envoy-",
+  "x-forwarded-"
+];
+var SET_COOKIE_SEPARATOR = "\n";
+function splitSetCookieHeader(value) {
+  return value.split(SET_COOKIE_SEPARATOR);
+}
+function appendHeaderValue(result, name, value) {
+  const key = name.toLowerCase();
+  const existing = result[key];
+  if (existing === void 0) {
+    result[key] = value;
+    return;
+  }
+  result[key] = key === "set-cookie" ? `${existing}${SET_COOKIE_SEPARATOR}${value}` : `${existing},${value}`;
+}
+function normalizeHeaders(input) {
+  if (!isPlainObject(input) && !Array.isArray(input)) {
+    return {};
+  }
+  const result = {};
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      if (!isPlainObject(item)) {
+        continue;
+      }
+      const { name, value } = item;
+      if (typeof name === "string" && value !== void 0) {
+        appendHeaderValue(result, name, String(value));
+      }
+    }
+    return result;
+  }
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        appendHeaderValue(result, key, String(item));
+      }
+      continue;
+    }
+    appendHeaderValue(result, key, String(value));
+  }
+  return result;
+}
+function parseUrl(input) {
+  try {
+    return new URL(input);
+  } catch {
+    return new URL(input, DUMMY_BASE_URL);
+  }
+}
+function getPathWithoutTrailingSlash(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+  return pathname;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileOpenApiPath(pathTemplate) {
+  const params = [];
+  let score = 0;
+  const absolutePath = pathTemplate.startsWith("/") ? pathTemplate : `/${pathTemplate}`;
+  const normalizedPath = getPathWithoutTrailingSlash(absolutePath);
+  const regexBody = normalizedPath.split("/").map((segment) => {
+    if (!segment) {
+      return "";
+    }
+    const paramMatch = segment.match(/^\{([^}]+)\}$/);
+    if (paramMatch) {
+      params.push(paramMatch[1]);
+      return "([^/]+)";
+    }
+    score += 2;
+    return escapeRegex(segment);
+  }).join("/");
+  return {
+    regex: new RegExp(`^${regexBody || "/"}$`),
+    params,
+    score
+  };
+}
+function parseJsonBodyIfPresent(contentType, bodyText) {
+  if (!bodyText) {
+    return void 0;
+  }
+  if (!isJsonMime(contentType)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeContentType(contentType) {
+  if (!contentType) {
+    return "";
+  }
+  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isJsonMime(contentType) {
+  const mime = normalizeContentType(contentType);
+  return mime === "application/json" || mime.endsWith("+json");
+}
+function pickSchemaByMime(contentMap, contentType) {
+  const requestedMime = normalizeContentType(contentType);
+  if (!requestedMime) {
+    return contentMap["application/json"] ?? contentMap["*/*"];
+  }
+  if (contentMap[requestedMime] !== void 0) {
+    return contentMap[requestedMime];
+  }
+  const [type, subtype] = requestedMime.split("/");
+  if (type && subtype) {
+    const wildcardSubtype = `${type}/*`;
+    if (contentMap[wildcardSubtype] !== void 0) {
+      return contentMap[wildcardSubtype];
+    }
+  }
+  return contentMap["*/*"];
+}
+function parseHeaderIgnoreList(patterns) {
+  const names = /* @__PURE__ */ new Set();
+  const prefixes = [];
+  for (const pattern of patterns) {
+    const normalized = pattern.trim().toLowerCase();
+    if (normalized.length === 0) {
+      continue;
+    }
+    if (normalized.endsWith("*")) {
+      prefixes.push(normalized.slice(0, -1));
+    } else {
+      names.add(normalized);
+    }
+  }
+  return { names, prefixes };
+}
+function shouldIgnoreHeaderAsUndocumented(headerName, extraIgnored) {
+  const normalizedHeaderName = headerName.toLowerCase();
+  if (normalizedHeaderName.startsWith(":")) {
+    return true;
+  }
+  if (IGNORED_UNDOCUMENTED_HEADERS.has(normalizedHeaderName) || IGNORED_UNDOCUMENTED_HEADER_PREFIXES.some((prefix) => normalizedHeaderName.startsWith(prefix))) {
+    return true;
+  }
+  if (extraIgnored) {
+    return extraIgnored.names.has(normalizedHeaderName) || extraIgnored.prefixes.some((prefix) => normalizedHeaderName.startsWith(prefix));
+  }
+  return false;
+}
+
+// src/commands/drift/log-formats/helpers.ts
+import { createReadStream } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
+function coerceString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (isPlainObject(value) || Array.isArray(value)) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+function coerceNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function decodeBody(value, encoding) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (encoding === "base64" && typeof value === "string") {
+    try {
+      return Buffer.from(value, "base64").toString("utf8");
+    } catch {
+      return value;
+    }
+  }
+  return coerceString(value);
+}
+function createNormalizedExchange(seed, index, source) {
+  const method = seed.method?.toUpperCase();
+  const url = seed.url;
+  if (!method || !url) {
+    return null;
+  }
+  const requestHeaders = normalizeHeaders(seed.requestHeaders);
+  let parsedUrl = parseUrl(url);
+  if (isSyntheticHost(parsedUrl.host) && requestHeaders.host) {
+    try {
+      parsedUrl = new URL(
+        `${parsedUrl.protocol}//${requestHeaders.host}${parsedUrl.pathname}${parsedUrl.search}`
+      );
+    } catch {
+      parsedUrl = parseUrl(url);
+    }
+  }
+  const requestContentType = seed.requestContentType ?? requestHeaders["content-type"];
+  const requestBodyText = decodeBody(seed.requestBody);
+  const request = {
+    method,
+    url: parsedUrl.toString(),
+    path: parsedUrl.pathname,
+    query: parsedUrl.searchParams,
+    protocol: parsedUrl.protocol,
+    protocolKnown: seed.schemeKnown ?? /^https?:\/\//i.test(url),
+    host: isSyntheticHost(parsedUrl.host) ? void 0 : parsedUrl.host || void 0,
+    headers: requestHeaders,
+    contentType: requestContentType,
+    bodyText: requestBodyText,
+    bodyJson: parseJsonBodyIfPresent(requestContentType, requestBodyText)
+  };
+  let response;
+  const responseStatus = seed.responseStatus;
+  if (responseStatus !== void 0) {
+    const responseHeaders = normalizeHeaders(seed.responseHeaders);
+    const responseContentType = seed.responseContentType ?? responseHeaders["content-type"];
+    const responseBodyText = decodeBody(seed.responseBody);
+    response = {
+      status: responseStatus,
+      statusText: seed.responseStatusText,
+      headers: responseHeaders,
+      contentType: responseContentType,
+      bodyText: responseBodyText,
+      bodyJson: parseJsonBodyIfPresent(responseContentType, responseBodyText)
+    };
+  }
+  return {
+    index,
+    source,
+    startedAt: seed.startedAt,
+    request,
+    response,
+    raw: seed.raw
+  };
+}
+async function* streamNdjsonObjects(filePath) {
+  const readStream = createReadStream(filePath, { encoding: "utf8" });
+  const reader = createInterface({ input: readStream, crlfDelay: Infinity });
+  for await (const line of reader) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isPlainObject(parsed)) {
+        yield parsed;
+      }
+    } catch {
+    }
+  }
+}
+async function* iterateJsonArray(filePath, arrayPath) {
+  const content = await readFile(filePath, "utf8");
+  let value = JSON.parse(content);
+  if (arrayPath) {
+    for (const key of arrayPath.split(".")) {
+      value = isPlainObject(value) ? value[key] : void 0;
+    }
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (isPlainObject(item)) {
+        yield item;
+      }
+    }
+  }
+}
+function pickHeaderContentType(headers) {
+  const normalized = normalizeHeaders(headers);
+  return normalized["content-type"];
+}
+
+// src/commands/drift/utils/server.ts
+function normalizeServerPrefix(server) {
+  const trimmed = server?.replace(/\/+$/, "");
+  return trimmed || void 0;
+}
+function stripPrefixFromPath(pathname, prefixPath) {
+  if (!prefixPath || prefixPath === "/") {
+    return pathname || "/";
+  }
+  if (pathname === prefixPath) {
+    return "/";
+  }
+  if (!pathname.startsWith(`${prefixPath}/`)) {
+    return void 0;
+  }
+  return pathname.slice(prefixPath.length) || "/";
+}
+function resolvePathForServer(request, server) {
+  if (server.startsWith("/")) {
+    return stripPrefixFromPath(request.path, server);
+  }
+  const serverUrl = parseUrl(server.includes("://") ? server : `http://${server}`);
+  if (isSyntheticHost(serverUrl.host) || request.host !== void 0 && request.host.toLowerCase() !== serverUrl.host) {
+    return void 0;
+  }
+  return stripPrefixFromPath(request.path, getPathWithoutTrailingSlash(serverUrl.pathname));
+}
+
+export {
+  listOpenApiFiles,
+  readProbe,
+  normalizeFsPath,
+  listFilesRecursively,
+  isSyntheticHost,
+  splitSetCookieHeader,
+  parseUrl,
+  getPathWithoutTrailingSlash,
+  compileOpenApiPath,
+  normalizeContentType,
+  isJsonMime,
+  pickSchemaByMime,
+  parseHeaderIgnoreList,
+  shouldIgnoreHeaderAsUndocumented,
+  coerceString,
+  coerceNumber,
+  decodeBody,
+  createNormalizedExchange,
+  streamNdjsonObjects,
+  iterateJsonArray,
+  pickHeaderContentType,
+  normalizeServerPrefix,
+  resolvePathForServer
+};

package/lib/chunks/{C5HID4LT.js → GBUMU6BX.js}

@@ -1,36 +1,19 @@
 import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
-  ValidationSession,
   coerceNumber,
   coerceString,
   createNormalizedExchange,
   decodeBody,
   iterateJsonArray,
-  listFilesRecursively,
-  loadOpenApiIndex,
   normalizeContentType,
-  normalizeFsPath,
-  parseCsv,
   pickHeaderContentType,
   readProbe,
-  renderReport,
   streamNdjsonObjects
-} from "./WST4KAJO.js";
+} from "./ER45DAHG.js";
 import {
-  AbortFlowError,
-  exitWithError
-} from "./U4V3W7MN.js";
-import {
-  isPlainObject,
-  logger
-} from "./KYZEVOA2.js";
-import "./Z2I5YXYN.js";
-import "./5ILQMFXK.js";
-
-// src/commands/drift/index.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import path5 from "node:path";
+  isPlainObject
+} from "./YK6T7IHG.js";
 
 // src/commands/drift/log-formats/har.ts
 import path from "node:path";
@@ -203,15 +186,15 @@ function buildUrl(record, request) {
     return { url: directUrl };
   }
   const host = coerceString(request?.host ?? request?.headers?.host ?? record?.host);
-  const path6 = coerceString(request?.path ?? record?.path ?? request?.pathname);
+  const path5 = coerceString(request?.path ?? record?.path ?? request?.pathname);
   const explicitScheme = coerceString(request?.scheme ?? record?.scheme);
-  if (host && path6) {
+  if (host && path5) {
     return {
-      url: `${explicitScheme ?? "http"}://${host}${path6}`,
+      url: `${explicitScheme ?? "http"}://${host}${path5}`,
       schemeKnown: Boolean(explicitScheme)
     };
   }
-  return { url: path6, schemeKnown: Boolean(explicitScheme) };
+  return { url: path5, schemeKnown: Boolean(explicitScheme) };
 }
 function normalizeGenericRecord(record, index, source) {
   const request = getRequestCandidate(record);
@@ -426,146 +409,6 @@ async function selectTrafficParser(filePath, format) {
   return PARSERS.find((candidate) => candidate.canParse(filePath, probe));
 }
 
-// src/commands/drift/engine/runner.ts
-async function runTrafficValidation(options) {
-  const trafficFiles = await listFilesRecursively(options.trafficPath);
-  if (trafficFiles.length === 0) {
-    throw new Error("No traffic files found in the provided traffic path.");
-  }
-  const session = ValidationSession.create({
-    openApiIndex: options.openApiIndex,
-    matchMode: options.matchMode,
-    ignoreCookies: options.ignoreCookies,
-    previewFindingsLimit: options.previewFindingsLimit,
-    activeRules: options.activeRules,
-    server: options.server,
-    minSeverity: options.minSeverity
-  });
-  let supportedTrafficFileCount = 0;
-  let exchangeIndex = 0;
-  for (const trafficFile of trafficFiles) {
-    const parser = await selectTrafficParser(trafficFile, options.format);
-    if (!parser) {
-      logger.warn(`Skipping traffic file with unrecognized format: ${trafficFile}
-`);
-      continue;
-    }
-    supportedTrafficFileCount += 1;
-    for await (const exchange of parser.parse(trafficFile)) {
-      await session.process({ ...exchange, index: exchangeIndex });
-      exchangeIndex += 1;
-    }
-  }
-  if (supportedTrafficFileCount === 0) {
-    throw new Error(
-      "No supported traffic files found. In auto mode, files must match built-in traffic parser signatures."
-    );
-  }
-  if (exchangeIndex === 0) {
-    throw new Error("No HTTP exchanges were parsed from the provided traffic files.");
-  }
-  return session.finalize();
-}
-
-// src/commands/drift/index.ts
-var USE_COLOR = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === void 0;
-function collectSpecServerUrls(openApiIndex) {
-  const urls = /* @__PURE__ */ new Set();
-  for (const operations of openApiIndex.operationsByMethod.values()) {
-    for (const operation of operations) {
-      for (const server of operation.servers) {
-        urls.add(server.rawUrl);
-      }
-    }
-  }
-  return Array.from(urls).sort();
-}
-function warnWhenNothingMatched(summary, openApiIndex, server) {
-  const validatedExchanges = summary.totalExchanges - summary.skippedExchanges;
-  if (validatedExchanges === 0 && summary.skippedExchanges > 0) {
-    logger.warn(
-      `All ${summary.skippedExchanges} exchange(s) were outside the --server "${server}" and were skipped. Check that the server matches the traffic URLs.
-`
-    );
-    return;
-  }
-  if (summary.documentedExchanges > 0 || validatedExchanges === 0) {
-    return;
-  }
-  const serverUrls = collectSpecServerUrls(openApiIndex);
-  const hint = server ? `Check that the --server "${server}" matches the traffic URLs and that the description paths align with the remainder.` : summary.hostCompatibleExchanges === validatedExchanges ? `The traffic hosts are compatible with the description servers (${serverUrls.join(
-    ", "
-  )}), so the endpoints are likely undocumented; if they should be documented, check that the description base paths and paths align with the traffic URLs, or use --server to declare the server the traffic was captured against.` : `Check that the traffic host and base path match the description servers (${serverUrls.join(
-    ", "
-  )}), or use --server to declare the server the traffic was captured against.`;
-  logger.warn(
-    `None of the ${validatedExchanges} validated exchange(s) matched a documented operation. ${hint}
-`
-  );
-}
-async function writeOutput(outputPath, content) {
-  const resolved = normalizeFsPath(outputPath);
-  await mkdir(path5.dirname(resolved), { recursive: true });
-  await writeFile(resolved, content, "utf8");
-}
-async function handleDrift({ argv, config }) {
-  const trafficPath = normalizeFsPath(argv.traffic);
-  const trafficFormat = argv["traffic-format"];
-  const activeRules = argv.rules ? parseCsv(argv.rules) : void 0;
-  const server = argv.server;
-  if (server && argv["match-mode"]) {
-    return exitWithError(
-      "The --server and --match-mode options are mutually exclusive: --match-mode controls how requests are located via the description servers, while --server replaces the description servers with the one the traffic was captured against."
-    );
-  }
-  const matchMode = argv["match-mode"] ?? "strict-host";
-  const specPath = normalizeFsPath(argv.api);
-  const openApiIndex = await loadOpenApiIndex(specPath, config);
-  if (openApiIndex.loadedOperations === 0) {
-    return exitWithError(`No OpenAPI operations were loaded from: ${specPath}`);
-  }
-  const { runId, summary, findings } = await runTrafficValidation({
-    trafficPath,
-    format: trafficFormat,
-    matchMode,
-    ignoreCookies: argv["ignore-cookies"],
-    previewFindingsLimit: argv["max-findings"],
-    activeRules,
-    openApiIndex,
-    server,
-    minSeverity: argv["min-severity"]
-  });
-  warnWhenNothingMatched(summary, openApiIndex, server);
-  const report = renderReport(
-    {
-      runId,
-      summary,
-      findings,
-      meta: {
-        specSource: specPath,
-        trafficPath,
-        format: trafficFormat,
-        matchMode,
-        server
-      }
-    },
-    {
-      format: argv["report-format"],
-      color: USE_COLOR && argv["report-format"] === "pretty" && !argv.output,
-      maxFindings: argv["max-findings"]
-    }
-  );
-  if (argv.output) {
-    await writeOutput(argv.output, report);
-    logger.info(`Drift report written to: ${normalizeFsPath(argv.output)}
-`);
-  } else {
-    logger.output(report);
-  }
-  if (summary.findingsBySeverity.error > 0) {
-    throw new AbortFlowError("Drift detected.");
-  }
-}
 export {
-  handleDrift
+  selectTrafficParser
 };