@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/oas/dist/{chunk-JMLIY2LK.js → chunk-LSH3X5NA.js}

@@ -1,15 +1,18 @@
 import {
   Operation,
-  Webhook
-} from "./chunk-BOVZLW7Q.js";
+  Webhook,
+  buildDiscriminatorOneOf,
+  findDiscriminatorChildren
+} from "./chunk-HGVFNEKW.js";
 import {
-  findSchemaDefinition,
+  SERVER_VARIABLE_REGEX,
   supportedMethods
-} from "./chunk-LV26LN7C.js";
+} from "./chunk-VA3NKXX7.js";
 import {
-  cloneObject,
+  dereferenceRef,
+  getDereferencingOptions,
   isPrimitive
-} from "./chunk-SH63AK3O.js";
+} from "./chunk-5EP6HY2E.js";
 import {
   CODE_SAMPLES,
   HEADERS,
@@ -20,107 +23,14 @@ import {
   getExtension,
   hasRootExtension,
   validateParameterOrdering
-} from "./chunk-TTCGKV5E.js";
+} from "./chunk-S27IGTVG.js";
 import {
+  isOpenAPI31,
   isRef
-} from "./chunk-L3V5TF63.js";
+} from "./chunk-7MARUOFZ.js";
 
 // src/index.ts
 import { dereference } from "@readme/openapi-parser";
-import { match, pathToRegexp } from "path-to-regexp";
-
-// src/lib/build-discriminator-one-of.ts
-function hasDiscriminatorWithoutPolymorphism(schema) {
-  if (!schema || typeof schema !== "object") return false;
-  if (!("discriminator" in schema)) return false;
-  if ("oneOf" in schema || "anyOf" in schema) return false;
-  return true;
-}
-function allOfReferencesSchema(schema, targetSchemaName) {
-  if (!schema || typeof schema !== "object") return false;
-  if (!("allOf" in schema) || !Array.isArray(schema.allOf)) return false;
-  return schema.allOf.some((item) => {
-    if (isRef(item)) {
-      const refParts = item.$ref.split("/");
-      const refSchemaName = refParts[refParts.length - 1];
-      return refSchemaName === targetSchemaName;
-    }
-    return false;
-  });
-}
-function findDiscriminatorChildren(api) {
-  const childrenMap = /* @__PURE__ */ new Map();
-  if (!api?.components?.schemas || typeof api.components.schemas !== "object") {
-    return childrenMap;
-  }
-  const schemas = api.components.schemas;
-  const schemaNames = Object.keys(schemas);
-  const discriminatorSchemas = schemaNames.filter((name) => {
-    return hasDiscriminatorWithoutPolymorphism(schemas[name]);
-  });
-  for (const baseName of discriminatorSchemas) {
-    const baseSchema = schemas[baseName];
-    const discriminator = baseSchema.discriminator;
-    let childSchemaNames;
-    if (discriminator.mapping && typeof discriminator.mapping === "object") {
-      const mappingRefs = Object.values(discriminator.mapping);
-      if (mappingRefs.length > 0) {
-        childSchemaNames = mappingRefs.map((ref) => {
-          const parts = ref.split("/");
-          return parts[parts.length - 1];
-        });
-      }
-    }
-    if (!childSchemaNames || childSchemaNames.length === 0) {
-      childSchemaNames = schemaNames.filter((name) => {
-        if (name === baseName) return false;
-        return allOfReferencesSchema(schemas[name], baseName);
-      });
-    }
-    if (childSchemaNames.length > 0) {
-      childrenMap.set(baseName, childSchemaNames);
-    }
-  }
-  return childrenMap;
-}
-function buildDiscriminatorOneOf(api, childrenMap) {
-  if (!api?.components?.schemas || typeof api.components.schemas !== "object") {
-    return;
-  }
-  if (childrenMap.size === 0) {
-    return;
-  }
-  const schemas = api.components.schemas;
-  for (const [schemaName, childNames] of childrenMap) {
-    const schema = schemas[schemaName];
-    if (!schema) continue;
-    const oneOf = [];
-    for (const childName of childNames) {
-      if (schemas[childName]) {
-        oneOf.push(cloneObject(schemas[childName]));
-      }
-    }
-    if (oneOf.length > 0) {
-      schema.oneOf = oneOf;
-    }
-  }
-  for (const [parentSchemaName, childNames] of childrenMap) {
-    for (const childName of childNames) {
-      const childSchema = schemas[childName];
-      if (!childSchema || !("allOf" in childSchema) || !Array.isArray(childSchema.allOf)) {
-        continue;
-      }
-      for (let i = 0; i < childSchema.allOf.length; i++) {
-        const item = childSchema.allOf[i];
-        if (item && typeof item === "object" && "x-readme-ref-name" in item && item["x-readme-ref-name"] === parentSchemaName && "oneOf" in item) {
-          const clonedItem = cloneObject(item);
-          delete clonedItem.oneOf;
-          childSchema.allOf[i] = clonedItem;
-        }
-      }
-    }
-  }
-}
 
 // src/lib/get-auth.ts
 function getKey(user, scheme) {
@@ -143,10 +53,11 @@ function getKey(user, scheme) {
 function getByScheme(user, scheme = {}, selectedApp) {
   if (user?.keys?.length) {
     if (selectedApp) {
-      return getKey(
-        user.keys.find((key) => key.name === selectedApp),
-        scheme
-      );
+      const userKey = user.keys.find((k) => k.name === selectedApp);
+      if (!userKey) {
+        return null;
+      }
+      return getKey(userKey, scheme);
     }
     return getKey(user.keys[0], scheme);
   }
@@ -154,19 +65,21 @@ function getByScheme(user, scheme = {}, selectedApp) {
 }
 function getAuth(api, user, selectedApp) {
   return Object.keys(api?.components?.securitySchemes || {}).map((scheme) => {
+    const securityScheme = dereferenceRef(api.components?.securitySchemes?.[scheme], api);
+    if (!securityScheme || isRef(securityScheme)) {
+      return false;
+    }
     return {
       [scheme]: getByScheme(
         user,
         {
-          // This sucks but since we dereference we'll never have a `$ref` pointer here with a
-          // `ReferenceObject` type.
-          ...api.components.securitySchemes[scheme],
+          ...securityScheme,
           _key: scheme
         },
         selectedApp
       )
     };
-  }).reduce((prev, next) => Object.assign(prev, next), {});
+  }).filter((item) => item !== void 0).reduce((prev, next) => Object.assign(prev, next), {});
 }
 
 // src/lib/get-user-variable.ts
@@ -179,11 +92,17 @@ function getUserVariable(user, property, selectedApp) {
       key = user.keys[0];
     }
   }
-  return key[property] || user[property] || null;
+  return key?.[property] || user[property] || null;
 }
 
-// src/index.ts
-var SERVER_VARIABLE_REGEX = /{([-_a-zA-Z0-9:.[\]]+)}/g;
+// src/lib/urls.ts
+import { match, pathToRegexp } from "path-to-regexp";
+function stripTrailingSlash(url) {
+  if (url[url.length - 1] === "/") {
+    return url.slice(0, -1);
+  }
+  return url;
+}
 function ensureProtocol(url) {
   if (url.match(/^\/\//)) {
     return `https:${url}`;
@@ -193,17 +112,11 @@ function ensureProtocol(url) {
   }
   return url;
 }
-function stripTrailingSlash(url) {
-  if (url[url.length - 1] === "/") {
-    return url.slice(0, -1);
-  }
-  return url;
-}
-function normalizedUrl(api, selected) {
+function normalizedURL(api, selected) {
   const exampleDotCom = "https://example.com";
   let url;
   try {
-    url = api.servers[selected].url;
+    url = api.servers?.[selected].url;
     if (!url) throw new Error("no url");
     url = stripTrailingSlash(url);
     if (url.startsWith("/") && !url.startsWith("//")) {
@@ -216,7 +129,7 @@ function normalizedUrl(api, selected) {
   }
   return ensureProtocol(url);
 }
-function transformUrlIntoRegex(url) {
+function transformURLIntoRegex(url) {
   return stripTrailingSlash(url.replace(SERVER_VARIABLE_REGEX, "([-_a-zA-Z0-9:.[\\]]+)"));
 }
 function normalizePath(path) {
@@ -226,7 +139,7 @@ function normalizePath(path) {
 }
 function generatePathMatches(paths, pathName, origin) {
   const prunedPathName = pathName.split("?")[0];
-  return Object.keys(paths).map((path) => {
+  const matches = Object.keys(paths).map((path) => {
     const cleanedPath = normalizePath(path);
     let matchResult;
     try {
@@ -251,7 +164,8 @@ function generatePathMatches(paths, pathName, origin) {
       operation: paths[path],
       match: matchResult
     };
-  }).filter(Boolean).filter((p) => p.match);
+  }).filter((item) => item !== false);
+  return matches.filter((p) => p.match);
 }
 function filterPathMethods(pathMatches, targetMethod) {
   const regExp = pathToRegexp(targetMethod);
@@ -266,21 +180,26 @@ function filterPathMethods(pathMatches, targetMethod) {
       };
     }
     return false;
-  }).filter(Boolean);
+  }).filter((item) => Boolean(item));
 }
 function findTargetPath(pathMatches) {
+  if (!pathMatches.length) {
+    return void 0;
+  }
   let minCount = Object.keys(pathMatches[0].url.slugs).length;
-  let operation;
+  let found;
   for (let m = 0; m < pathMatches.length; m += 1) {
     const selection = pathMatches[m];
     const paramCount = Object.keys(selection.url.slugs).length;
     if (paramCount <= minCount) {
       minCount = paramCount;
-      operation = selection;
+      found = selection;
     }
   }
-  return operation;
+  return found;
 }
+
+// src/index.ts
 var Oas = class _Oas {
   /**
    * An OpenAPI API Definition.
@@ -349,18 +268,11 @@ var Oas = class _Oas {
     return this.api;
   }
   url(selected = 0, variables) {
-    const url = normalizedUrl(this.api, selected);
+    const url = normalizedURL(this.api, selected);
     return this.replaceUrl(url, variables || this.defaultVariables(selected)).trim();
   }
   variables(selected = 0) {
-    let variables;
-    try {
-      variables = this.api.servers[selected].variables;
-      if (!variables) throw new Error("no variables");
-    } catch {
-      variables = {};
-    }
-    return variables;
+    return this.api.servers?.[selected]?.variables || {};
   }
   defaultVariables(selected = 0) {
     const variables = this.variables(selected);
@@ -371,7 +283,7 @@ var Oas = class _Oas {
     return defaults;
   }
   splitUrl(selected = 0) {
-    const url = normalizedUrl(this.api, selected);
+    const url = normalizedURL(this.api, selected);
     const variables = this.variables(selected);
     return url.split(/({.+?})/).filter(Boolean).map((part, i) => {
       const isVariable = part.match(/[{}]/);
@@ -410,7 +322,7 @@ var Oas = class _Oas {
    */
   splitVariables(baseUrl) {
     const matchedServer = (this.api.servers || []).map((server, i) => {
-      const rgx = transformUrlIntoRegex(server.url);
+      const rgx = transformURLIntoRegex(server.url);
       const found = new RegExp(rgx).exec(baseUrl);
       if (!found) {
         return false;
@@ -423,7 +335,7 @@ var Oas = class _Oas {
         selected: i,
         variables
       };
-    }).filter(Boolean);
+    }).filter((item) => item !== false);
     return matchedServer.length ? matchedServer[0] : false;
   }
   /**
@@ -452,15 +364,15 @@ var Oas = class _Oas {
           const data = variables[key];
           if (typeof data === "object") {
             if (!Array.isArray(data) && data !== null && "default" in data) {
-              return data.default;
+              return String(data.default);
             }
           } else {
-            return data;
+            return String(data);
           }
         }
         const userVariable = getUserVariable(this.user, key);
         if (userVariable) {
-          return userVariable;
+          return String(userVariable);
         }
         return original;
       })
@@ -477,14 +389,21 @@ var Oas = class _Oas {
       parameters: []
     };
     if (opts.isWebhook) {
-      const api = this.api;
-      if (api?.webhooks[path]?.[method]) {
-        operation = api.webhooks[path][method];
-        return new Webhook(api, path, method, operation);
+      if (isOpenAPI31(this.api)) {
+        const webhookPath = dereferenceRef(this.api?.webhooks?.[path], this.api);
+        if (webhookPath && !isRef(webhookPath)) {
+          if (webhookPath?.[method]) {
+            operation = webhookPath[method];
+            return new Webhook(this.api, path, method, operation);
+          }
+        }
       }
     }
-    if (this?.api?.paths?.[path]?.[method]) {
-      operation = this.api.paths[path][method];
+    if (this?.api?.paths?.[path]) {
+      const pathItem = dereferenceRef(this.api.paths[path], this.api);
+      if (pathItem?.[method]) {
+        operation = dereferenceRef(pathItem[method], this.api);
+      }
     }
     return new Operation(this.api, path, method, operation);
   }
@@ -514,8 +433,8 @@ var Oas = class _Oas {
       [, pathName] = url.split(new RegExp(targetServer.url, "i"));
     }
     if (!matchedServer || !pathName) {
-      const matchedServerAndPath = servers.map((server) => {
-        const rgx = transformUrlIntoRegex(server.url);
+      const matchedServerAndPath = (servers || []).map((server) => {
+        const rgx = transformURLIntoRegex(server.url);
         const found = new RegExp(rgx).exec(url);
         if (!found) {
           return void 0;
@@ -524,7 +443,7 @@ var Oas = class _Oas {
           matchedServer: server,
           pathName: url.split(new RegExp(rgx)).slice(-1).pop()
         };
-      }).filter(Boolean);
+      }).filter((item) => item !== void 0);
       if (!matchedServerAndPath.length) {
         return void 0;
       }
@@ -535,6 +454,7 @@ var Oas = class _Oas {
     }
     if (pathName === void 0) return void 0;
     if (pathName === "") pathName = "/";
+    if (!paths || !targetServer) return void 0;
     const annotatedPaths = generatePathMatches(paths, pathName, targetServer.url);
     if (!annotatedPaths.length) return void 0;
     return annotatedPaths;
@@ -634,16 +554,24 @@ var Oas = class _Oas {
    */
   getPaths() {
     const paths = {};
-    Object.keys(this.api.paths ? this.api.paths : []).forEach((path) => {
+    if (!this.api.paths) {
+      return paths;
+    }
+    Object.keys(this.api.paths).forEach((path) => {
       if (path.startsWith("x-")) {
         return;
       }
       paths[path] = {};
-      if ("$ref" in this.api.paths[path]) {
-        this.api.paths[path] = findSchemaDefinition(this.api.paths[path].$ref, this.api);
+      const pathItem = this.api.paths[path];
+      if (!pathItem) {
+        return;
+      } else if (isRef(pathItem)) {
+        this.api.paths[path] = dereferenceRef(pathItem, this.api);
       }
-      Object.keys(this.api.paths[path]).forEach((method) => {
-        if (!supportedMethods.includes(method)) return;
+      Object.keys(pathItem).forEach((method) => {
+        if (!supportedMethods.includes(method)) {
+          return;
+        }
         paths[path][method] = this.operation(path, method);
       });
     });
@@ -658,18 +586,31 @@ var Oas = class _Oas {
    */
   getWebhooks() {
     const webhooks = {};
-    const api = this.api;
-    Object.keys(api.webhooks ? api.webhooks : []).forEach((id) => {
+    if (!isOpenAPI31(this.api) || !this.api.webhooks) {
+      return webhooks;
+    }
+    Object.keys(this.api.webhooks).forEach((id) => {
       webhooks[id] = {};
-      Object.keys(api.webhooks[id]).forEach((method) => {
-        webhooks[id][method] = this.operation(id, method, { isWebhook: true });
-      });
+      const webhookPath = dereferenceRef(this.api.webhooks?.[id], this.api);
+      if (webhookPath) {
+        Object.keys(webhookPath).forEach((method) => {
+          if (!supportedMethods.includes(method)) {
+            return;
+          }
+          webhooks[id][method] = this.operation(id, method, {
+            isWebhook: true
+          });
+        });
+      }
     });
     return webhooks;
   }
   /**
    * Return an array of all tag names that exist on this API definition.
    *
+   * If the API definition uses the `x-disable-tag-sorting` extension then tags will be returned in
+   * the order they're defined.
+   *
    * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.0.md#openapi-object}
    * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#openapi-object}
    * @param setIfMissing If a tag is not present on an operation that operations path will be added
@@ -677,9 +618,7 @@ var Oas = class _Oas {
    */
   getTags(setIfMissing = false) {
     const allTags = /* @__PURE__ */ new Set();
-    const oasTags = this.api.tags?.map((tag) => {
-      return tag.name;
-    }) || [];
+    const oasTags = this.api.tags?.map((tag) => tag.name) || [];
     const disableTagSorting = getExtension("disable-tag-sorting", this.api);
     Object.entries(this.getPaths()).forEach(([path, operations]) => {
       Object.values(operations).forEach((operation) => {
@@ -760,11 +699,13 @@ var Oas = class _Oas {
       }
       if (extension in data) {
         if ([CODE_SAMPLES, HEADERS, PARAMETER_ORDERING, SAMPLES_LANGUAGES].includes(extension)) {
-          if (!Array.isArray(data[extension])) {
-            throw new TypeError(`"x-readme.${extension}" must be of type "Array"`);
-          }
-          if (extension === PARAMETER_ORDERING) {
-            validateParameterOrdering(data[extension], `x-readme.${extension}`);
+          if (data[extension] !== void 0) {
+            if (!Array.isArray(data[extension])) {
+              throw new TypeError(`"x-readme.${extension}" must be of type "Array"`);
+            }
+            if (extension === PARAMETER_ORDERING) {
+              validateParameterOrdering(data[extension], `x-readme.${extension}`);
+            }
           }
         } else if (extension === OAUTH_OPTIONS) {
           if (typeof data[extension] !== "object") {
@@ -814,7 +755,7 @@ var Oas = class _Oas {
    */
   getCircularReferences() {
     if (!this.dereferencing.complete) {
-      throw new Error("#dereference() must be called first in order for this method to obtain circular references.");
+      throw new Error(".dereference() must be called first in order for this method to obtain circular references.");
     }
     return this.dereferencing.circularRefs;
   }
@@ -835,36 +776,24 @@ var Oas = class _Oas {
       });
     }
     this.dereferencing.processing = true;
-    const discriminatorChildrenMap = findDiscriminatorChildren(this.api);
+    const { children: discriminatorChildrenMap } = findDiscriminatorChildren(this.api);
     const { api, promises } = this;
     if (api?.components?.schemas && typeof api.components.schemas === "object") {
       Object.keys(api.components.schemas).forEach((schemaName) => {
-        if (isPrimitive(api.components.schemas[schemaName]) || Array.isArray(api.components.schemas[schemaName]) || api.components.schemas[schemaName] === null) {
+        if (isPrimitive(api.components?.schemas?.[schemaName]) || Array.isArray(api.components?.schemas?.[schemaName]) || api.components?.schemas?.[schemaName] === null) {
           return;
         }
         if (opts.preserveRefAsJSONSchemaTitle) {
-          api.components.schemas[schemaName].title = schemaName;
+          (api.components?.schemas?.[schemaName]).title = schemaName;
         }
-        api.components.schemas[schemaName]["x-readme-ref-name"] = schemaName;
+        (api.components?.schemas?.[schemaName])["x-readme-ref-name"] = schemaName;
       });
     }
     const circularRefs = /* @__PURE__ */ new Set();
-    return dereference(api, {
-      resolve: {
-        // We shouldn't be resolving external pointers at this point so just ignore them.
-        external: false
-      },
-      dereference: {
-        // If circular `$refs` are ignored they'll remain in the OAS as `$ref: String`, otherwise
-        // `$ref‘ just won't exist. This allows us to do easy circular reference detection.
-        circular: "ignore",
-        onCircular: (path) => {
-          circularRefs.add(`#${path.split("#")[1]}`);
-        }
-      }
-    }).then((dereferenced) => {
+    const dereferencingOptions = getDereferencingOptions(circularRefs);
+    return dereference(api, dereferencingOptions).then((dereferenced) => {
       this.api = dereferenced;
-      if (discriminatorChildrenMap && discriminatorChildrenMap.size > 0) {
+      if (this.api?.components?.schemas && discriminatorChildrenMap.size > 0) {
         buildDiscriminatorOneOf(this.api, discriminatorChildrenMap);
       }
       this.promises = promises;
@@ -879,6 +808,10 @@ var Oas = class _Oas {
       }
     }).then(() => {
       return this.promises.map((deferred) => deferred.resolve());
+    }).catch((err) => {
+      this.dereferencing.processing = false;
+      this.promises.map((deferred) => deferred.reject(err));
+      throw err;
     });
   }
 };
@@ -886,4 +819,4 @@ var Oas = class _Oas {
 export {
   Oas
 };
-//# sourceMappingURL=chunk-JMLIY2LK.js.map
+//# sourceMappingURL=chunk-LSH3X5NA.js.map

package/.output/server/node_modules/oas/dist/{chunk-TTCGKV5E.js → chunk-S27IGTVG.js}

@@ -60,6 +60,9 @@ function getExtension(extension, api, operation) {
   return void 0;
 }
 function validateParameterOrdering(ordering, extension) {
+  if (!ordering) {
+    return;
+  }
   const defaultValue = extensionDefaults[PARAMETER_ORDERING];
   const requiredLength = defaultValue.length;
   const defaultsHuman = `${defaultValue.slice(0, -1).join(", ")}, and ${defaultValue.slice(-1)}`;
@@ -89,4 +92,4 @@ export {
   getExtension,
   validateParameterOrdering
 };
-//# sourceMappingURL=chunk-TTCGKV5E.js.map
+//# sourceMappingURL=chunk-S27IGTVG.js.map

package/.output/server/node_modules/oas/dist/chunk-VA3NKXX7.js

@@ -0,0 +1,9 @@
+// src/utils.ts
+var supportedMethods = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+var SERVER_VARIABLE_REGEX = /{([-_a-zA-Z0-9:.[\]]+)}/g;
+
+export {
+  supportedMethods,
+  SERVER_VARIABLE_REGEX
+};
+//# sourceMappingURL=chunk-VA3NKXX7.js.map

package/.output/server/node_modules/oas/dist/index.js

@@ -1,11 +1,11 @@
 import {
   Oas
-} from "./chunk-JMLIY2LK.js";
-import "./chunk-BOVZLW7Q.js";
-import "./chunk-LV26LN7C.js";
-import "./chunk-SH63AK3O.js";
-import "./chunk-TTCGKV5E.js";
-import "./chunk-L3V5TF63.js";
+} from "./chunk-LSH3X5NA.js";
+import "./chunk-HGVFNEKW.js";
+import "./chunk-VA3NKXX7.js";
+import "./chunk-5EP6HY2E.js";
+import "./chunk-S27IGTVG.js";
+import "./chunk-7MARUOFZ.js";
 export {
   Oas as default
 };

package/.output/server/node_modules/oas/dist/types.js

@@ -1,15 +1,11 @@
 import {
-  isOAS30,
-  isOAS31,
   isOpenAPI30,
   isOpenAPI31,
   isRef,
   isSchema,
   isSwagger
-} from "./chunk-L3V5TF63.js";
+} from "./chunk-7MARUOFZ.js";
 export {
-  isOAS30,
-  isOAS31,
   isOpenAPI30,
   isOpenAPI31,
   isRef,

package/.output/server/node_modules/oas/dist/utils.js

@@ -1,16 +1,16 @@
 import {
-  findSchemaDefinition,
+  SERVER_VARIABLE_REGEX,
   supportedMethods
-} from "./chunk-LV26LN7C.js";
+} from "./chunk-VA3NKXX7.js";
 import {
   getParameterContentType,
   matches_mimetype_default,
   types
-} from "./chunk-SH63AK3O.js";
-import "./chunk-TTCGKV5E.js";
-import "./chunk-L3V5TF63.js";
+} from "./chunk-5EP6HY2E.js";
+import "./chunk-S27IGTVG.js";
+import "./chunk-7MARUOFZ.js";
 export {
-  findSchemaDefinition,
+  SERVER_VARIABLE_REGEX,
   getParameterContentType,
   types as jsonSchemaTypes,
   matches_mimetype_default as matchesMimeType,