oas 36.0.2 → 37.0.0

package/dist/{chunk-35LEYZEY.js → chunk-WIVQX3DA.js}

@@ -1,4 +1,5 @@
 import {
+  SERVER_VARIABLE_REGEX,
   applyDiscriminatorOneOfToUsedSchemas,
   cloneObject,
   collectRefsInSchema,
@@ -6,7 +7,6 @@ import {
   dereferenceRef,
   dereferenceRefDeep,
   filterRequiredRefsToReferenced,
-  getDereferencingOptions,
   getParametersAsJSONSchema,
   getSchemaVersionString,
   isObject,
@@ -15,7 +15,7 @@ import {
   mergeReferencedSchemasIntoRoot,
   supportedMethods,
   toJSONSchema
-} from "./chunk-6MDVLJ3A.js";
+} from "./chunk-IEN4GZPF.js";
 import {
   getExtension
 } from "./chunk-S27IGTVG.js";
@@ -23,8 +23,159 @@ import {
   isRef
 } from "./chunk-XG4HGNCN.js";
 
-// src/operation/index.ts
-import { $RefParser } from "@apidevtools/json-schema-ref-parser";
+// src/lib/urls.ts
+import { match, pathToRegexp } from "path-to-regexp";
+
+// src/lib/get-user-variable.ts
+function getUserVariable(user, property, selectedApp) {
+  let key = user;
+  if ("keys" in user && Array.isArray(user.keys) && user.keys.length) {
+    if (selectedApp) {
+      key = user.keys.find((k) => k.name === selectedApp);
+    } else {
+      key = user.keys[0];
+    }
+  }
+  return key?.[property] || user[property] || null;
+}
+
+// src/lib/urls.ts
+function stripTrailingSlash(url) {
+  if (url[url.length - 1] === "/") {
+    return url.slice(0, -1);
+  }
+  return url;
+}
+function ensureProtocol(url) {
+  if (url.match(/^\/\//)) {
+    return `https:${url}`;
+  }
+  if (!url.match(/\/\//)) {
+    return `https://${url}`;
+  }
+  return url;
+}
+function normalizedURLFromServers(servers, selected) {
+  const exampleDotCom = "https://example.com";
+  let url;
+  try {
+    url = servers?.[selected]?.url;
+    if (!url) throw new Error("no url");
+    url = stripTrailingSlash(url);
+    if (url.startsWith("/") && !url.startsWith("//")) {
+      const urlWithOrigin = new URL(exampleDotCom);
+      urlWithOrigin.pathname = url;
+      url = urlWithOrigin.href;
+    }
+  } catch {
+    url = exampleDotCom;
+  }
+  return ensureProtocol(url);
+}
+function variablesFromServers(servers, selected = 0) {
+  return servers?.[selected]?.variables || {};
+}
+function defaultVariablesFromServers(servers, selected = 0, user = {}) {
+  const variables = variablesFromServers(servers, selected);
+  const defaults = {};
+  Object.keys(variables).forEach((key) => {
+    defaults[key] = getUserVariable(user, key) || variables[key].default || "";
+  });
+  return defaults;
+}
+function splitUrlFromServers(servers, selected = 0) {
+  const url = normalizedURLFromServers(servers, selected);
+  const variables = variablesFromServers(servers, selected);
+  return url.split(/({.+?})/).filter(Boolean).map((part, i) => {
+    const isVariable = part.match(/[{}]/);
+    const value = part.replace(/[{}]/g, "");
+    const key = `${value}-${i}`;
+    if (!isVariable) {
+      return {
+        type: "text",
+        value,
+        key
+      };
+    }
+    const variable = variables?.[value];
+    return {
+      type: "variable",
+      value,
+      key,
+      description: variable?.description,
+      enum: variable?.enum
+    };
+  });
+}
+function transformURLIntoRegex(url) {
+  return stripTrailingSlash(url.replace(SERVER_VARIABLE_REGEX, "([-_a-zA-Z0-9:.[\\]]+)"));
+}
+function normalizePath(path) {
+  return path.replace(/({?){(.*?)}(}?)/g, (str, ...args) => {
+    return `:${args[1].replace("-", "")}`;
+  }).replace(/::/, "\\::").split("?")[0];
+}
+function generatePathMatches(paths, pathName, origin) {
+  const prunedPathName = pathName.split("?")[0];
+  const matches = Object.keys(paths).map((path) => {
+    const cleanedPath = normalizePath(path);
+    let matchResult;
+    try {
+      const matchStatement = match(cleanedPath, { decode: decodeURIComponent });
+      matchResult = matchStatement(prunedPathName);
+    } catch {
+      return false;
+    }
+    const slugs = {};
+    if (matchResult && Object.keys(matchResult.params).length) {
+      Object.keys(matchResult.params).forEach((param) => {
+        slugs[`:${param}`] = matchResult.params[param];
+      });
+    }
+    return {
+      url: {
+        origin,
+        path: cleanedPath.replace(/\\::/, "::"),
+        nonNormalizedPath: path,
+        slugs
+      },
+      operation: paths[path],
+      match: matchResult
+    };
+  }).filter((item) => item !== false);
+  return matches.filter((p) => p.match);
+}
+function filterPathMethods(pathMatches, targetMethod) {
+  const regExp = pathToRegexp(targetMethod);
+  return pathMatches.map((p) => {
+    const captures = Object.keys(p.operation).filter((r) => regExp.regexp.exec(r));
+    if (captures.length) {
+      const method = captures[0];
+      p.url.method = method.toUpperCase();
+      return {
+        url: p.url,
+        operation: p.operation[method]
+      };
+    }
+    return false;
+  }).filter((item) => Boolean(item));
+}
+function findTargetPath(pathMatches) {
+  if (!pathMatches.length) {
+    return void 0;
+  }
+  let minCount = Object.keys(pathMatches[0].url.slugs).length;
+  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;
+      found = selection;
+    }
+  }
+  return found;
+}
 
 // src/operation/lib/dedupe-common-parameters.ts
 function dedupeCommonParameters(parameters, commonParameters) {
@@ -42,7 +193,6 @@ function dedupeCommonParameters(parameters, commonParameters) {
 
 // src/samples/index.ts
 import mergeJSONSchemaAllOf from "json-schema-merge-allof";
-import memoize from "memoizee";
 
 // src/samples/utils.ts
 function usesPolymorphism(schema) {
@@ -255,8 +405,6 @@ function sampleFromResolvedSchema(schema, opts, seenRefs) {
   }
   return primitive(schema);
 }
-var memo = memoize(sampleFromSchema);
-var samples_default = memo;
 
 // src/operation/lib/get-mediatype-examples.ts
 function getMediaTypeExamples(mediaType, mediaTypeObject, definition, opts = {}) {
@@ -311,7 +459,7 @@ function getMediaTypeExamples(mediaType, mediaTypeObject, definition, opts = {})
     if (!matches_mimetype_default.xml(mediaType)) {
       return [
         {
-          value: samples_default(structuredClone(mediaTypeObject.schema), {
+          value: sampleFromSchema(structuredClone(mediaTypeObject.schema), {
             ...opts,
             definition
           })
@@ -555,7 +703,7 @@ function getOperationId(path, method, operation, opts = {}) {
     if (operationIdExists) {
       operationId = sanitize(operationId);
     }
-    operationId = operationId.replace(/^[0-9]/g, (match) => `_${match}`);
+    operationId = operationId.replace(/^[0-9]/g, (match2) => `_${match2}`);
     operationId = operationId.charAt(0).toLowerCase() + operationId.slice(1);
     if (operationId.startsWith(currMethod)) {
       return operationId;
@@ -793,24 +941,6 @@ var Operation = class {
    * Flattened out arrays of both request and response headers that are utilized on this operation.
    */
   headers;
-  /**
-   * Internal storage array that the library utilizes to keep track of the times the
-   * {@see Operation.dereference} has been called so that if you initiate multiple promises they'll
-   * all end up returning the same data set once the initial dereference call completed.
-   */
-  promises;
-  /**
-   * Internal storage array that the library utilizes to keep track of its `dereferencing` state so
-   * it doesn't initiate multiple dereferencing processes.
-   */
-  dereferencing;
-  /**
-   * Have the component schemas within this API definition been decorated with our
-   * `x-readme-ref-name` extension?
-   *
-   * @see {@link decorateComponentSchemas}
-   */
-  schemasDecorated = false;
   constructor(oas, path, method, operation) {
     this.oas = oas;
     this.schema = operation;
@@ -826,12 +956,6 @@ var Operation = class {
       request: [],
       response: []
     };
-    this.promises = [];
-    this.dereferencing = {
-      processing: false,
-      complete: false,
-      circularRefs: []
-    };
   }
   /**
    * Retrieve the `summary` for this operation.
@@ -865,6 +989,35 @@ var Operation = class {
     }
     return void 0;
   }
+  /**
+   * Retrieve the server objects that apply to this operation, using OpenAPI server precedence:
+   * operation-level servers, then path-item servers, then root-level servers.
+   */
+  getServers() {
+    if (this.schema.servers?.length) {
+      return this.schema.servers;
+    }
+    if (this.api.paths?.[this.path]) {
+      const pathItem = dereferenceRef(this.api.paths[this.path], this.api);
+      if (pathItem && !isRef(pathItem) && pathItem.servers?.length) {
+        return pathItem.servers;
+      }
+    }
+    return this.api.servers || [];
+  }
+  url(selected = 0, variables) {
+    const url = normalizedURLFromServers(this.getServers(), selected);
+    return this.oas.replaceUrl(url, variables || this.defaultVariables(selected)).trim();
+  }
+  variables(selected = 0) {
+    return variablesFromServers(this.getServers(), selected);
+  }
+  defaultVariables(selected = 0) {
+    return defaultVariablesFromServers(this.getServers(), selected, this.oas.user);
+  }
+  splitUrl(selected = 0) {
+    return splitUrlFromServers(this.getServers(), selected);
+  }
   /**
    * Retrieve the primary content type for this operation. If multiple exist, the first JSON-like
    * type will be returned.
@@ -1248,15 +1401,7 @@ var Operation = class {
    *
    */
   getParametersAsJSONSchema(opts = {}) {
-    if (this.isDereferenced()) {
-      throw new Error(
-        "`.getParametersAsJSONSchema()` is not compatible with an operation or OpenAPI definition that has been run through `.dereference().`"
-      );
-    }
-    if (!this.schemasDecorated) {
-      decorateComponentSchemasWithRefName(this.api);
-      this.schemasDecorated = true;
-    }
+    decorateComponentSchemasWithRefName(this.api);
     return getParametersAsJSONSchema(this, this.api, {
       includeDiscriminatorMappingRefs: true,
       ...opts
@@ -1276,15 +1421,7 @@ var Operation = class {
    *   this content-type, the function will return null.
    */
   getResponseAsJSONSchema(statusCode, opts = {}) {
-    if (this.isDereferenced()) {
-      throw new Error(
-        "`.getResponseAsJSONSchema()` is not compatible with an operation or OpenAPI definition that has been run through `.dereference().`"
-      );
-    }
-    if (!this.schemasDecorated) {
-      decorateComponentSchemasWithRefName(this.api);
-      this.schemasDecorated = true;
-    }
+    decorateComponentSchemasWithRefName(this.api);
     return getResponseAsJSONSchema(this, this.api, statusCode, {
       includeDiscriminatorMappingRefs: true,
       ...opts
@@ -1630,107 +1767,6 @@ var Operation = class {
     this.exampleGroups = groups;
     return groups;
   }
-  /**
-   * Dereference the current operation schema so it can be parsed free of worries of `$ref` schemas
-   * and circular structures.
-   *
-   */
-  async dereference(opts) {
-    if (this.dereferencing.complete) {
-      return Promise.resolve(true);
-    }
-    if (this.dereferencing.processing) {
-      return new Promise((resolve, reject) => {
-        this.promises.push({ resolve, reject });
-      });
-    }
-    this.dereferencing.processing = true;
-    if (!this.schemasDecorated) {
-      decorateComponentSchemasWithRefName(this.api);
-      this.schemasDecorated = true;
-    }
-    const { api, schema, promises } = this;
-    const circularRefs = /* @__PURE__ */ new Set();
-    const dereferencingOptions = getDereferencingOptions(circularRefs);
-    const parser = new $RefParser();
-    return parser.dereference(
-      "#/__INTERNAL__",
-      {
-        // Because `json-schema-ref-parser` will dereference this entire object as we only want
-        // to dereference this operation schema we're attaching it to the `__INTERNAL__` key, and
-        // later using that to extract our dereferenced schema. If we didn't do this then we run
-        // the risk of any keyword in `schema` being overriden by `paths` and `components`.
-        //
-        // This solution isn't the best and still requires us to send `json-schema-ref-parser`
-        // basically the entire API defintiion but because we don't know what `$ref` pointers in
-        // `schema` reference, we can't know which parts of full API definition we could safely
-        // exclude from this process.
-        __INTERNAL__: structuredClone(schema),
-        paths: api.paths ?? void 0,
-        components: api.components ?? void 0
-      },
-      {
-        ...dereferencingOptions,
-        dereference: {
-          ...dereferencingOptions.dereference,
-          /**
-           * Because we only want to dereference our `__INTERNAL__` schema, not the **entire**
-           * API definition if the parser attemps to dereference anything but that then we
-           * should bail out of that crawler.
-           *
-           * @fixme this may cause issues where a path references a schema within itself to be ignored.
-           */
-          excludedPathMatcher: (path) => {
-            if (path === "#/paths" || path.startsWith("#/paths/")) {
-              return true;
-            }
-            return path === "#/components" || path.startsWith("#/components/");
-          }
-        }
-      }
-    ).then((res) => {
-      const dereferenced = res;
-      this.schema = dereferenced.__INTERNAL__;
-      this.promises = promises;
-      this.dereferencing = {
-        processing: false,
-        complete: true,
-        // We need to convert our `Set` to an array in order to match the typings.
-        circularRefs: [...circularRefs]
-      };
-      if (opts?.cb) {
-        opts.cb();
-      }
-    }).then(() => {
-      return this.promises.map((deferred) => deferred.resolve());
-    }).catch((err) => {
-      this.dereferencing.processing = false;
-      this.promises.map((deferred) => deferred.reject(err));
-      throw err;
-    });
-  }
-  /**
-   * Determine if the current operation schema, or the OpenAPI definition it's part of, has been
-   * dereferenced or not with `.dereference()`.
-   *
-   * @see Operation.dereference
-   */
-  isDereferenced() {
-    return this.oas.isDereferenced() || this.dereferencing.processing || this.dereferencing.complete;
-  }
-  /**
-   * Retrieve any circular `$ref` pointers that maybe present within operation schema.
-   *
-   * This method requires that you first dereference the definition.
-   *
-   * @see Operation.dereference
-   */
-  getCircularReferences() {
-    if (!this.dereferencing.complete) {
-      throw new Error(".dereference() must be called first in order for this method to obtain circular references.");
-    }
-    return this.dereferencing.circularRefs;
-  }
 };
 var Callback = class extends Operation {
   /**
@@ -1854,6 +1890,16 @@ var Webhook = class extends Operation {
 };
 
 export {
+  getUserVariable,
+  stripTrailingSlash,
+  normalizedURLFromServers,
+  variablesFromServers,
+  defaultVariablesFromServers,
+  splitUrlFromServers,
+  transformURLIntoRegex,
+  generatePathMatches,
+  filterPathMethods,
+  findTargetPath,
   Operation,
   Callback,
   Webhook
@@ -1870,4 +1916,4 @@ export {
  * @license Apache-2.0
  * @see {@link https://github.com/swagger-api/swagger-ui/blob/master/src/core/plugins/samples/fn.js}
  */
-//# sourceMappingURL=chunk-35LEYZEY.js.map
+//# sourceMappingURL=chunk-WIVQX3DA.js.map