@readme/api-core 7.0.0-alpha.3 → 7.0.0-alpha.4

package/dist/index.js

@@ -1,96 +1,515 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareServer = exports.prepareParams = exports.prepareAuth = exports.parseResponse = exports.getJSONSchemaDefaults = void 0;
-const oas_to_har_1 = __importDefault(require("@readme/oas-to-har"));
-const fetch_har_1 = __importDefault(require("fetch-har"));
-const fetchError_1 = __importDefault(require("./errors/fetchError"));
-const getJSONSchemaDefaults_1 = __importDefault(require("./lib/getJSONSchemaDefaults"));
-exports.getJSONSchemaDefaults = getJSONSchemaDefaults_1.default;
-const parseResponse_1 = __importDefault(require("./lib/parseResponse"));
-exports.parseResponse = parseResponse_1.default;
-const prepareAuth_1 = __importDefault(require("./lib/prepareAuth"));
-exports.prepareAuth = prepareAuth_1.default;
-const prepareParams_1 = __importDefault(require("./lib/prepareParams"));
-exports.prepareParams = prepareParams_1.default;
-const prepareServer_1 = __importDefault(require("./lib/prepareServer"));
-exports.prepareServer = prepareServer_1.default;
-class APICore {
-    spec;
-    auth = [];
-    server = false;
-    config = {};
-    userAgent;
-    constructor(spec, userAgent) {
-        if (spec)
-            this.spec = spec;
-        if (userAgent)
-            this.userAgent = userAgent;
+import {
+  FetchError
+} from "./chunk-L7DN22AA.js";
+
+// src/index.ts
+import oasToHar from "@readme/oas-to-har";
+import fetchHar from "fetch-har";
+
+// src/lib/getJSONSchemaDefaults.ts
+import traverse from "json-schema-traverse";
+function getJSONSchemaDefaults(jsonSchemas) {
+  return jsonSchemas.map(({ type: payloadType, schema: jsonSchema }) => {
+    const defaults = {};
+    traverse(
+      jsonSchema,
+      (schema, pointer, rootSchema, parentPointer, parentKeyword, parentSchema, indexProperty) => {
+        if (!pointer.startsWith("/properties/")) {
+          return;
+        }
+        if (Array.isArray(parentSchema?.required) && parentSchema?.required.includes(String(indexProperty))) {
+          if (schema.type === "object" && indexProperty) {
+            defaults[indexProperty] = {};
+          }
+          let destination = defaults;
+          if (parentPointer) {
+            parentPointer.replace(/\/properties/g, "").split("/").forEach((subSchema) => {
+              if (subSchema === "") {
+                return;
+              }
+              destination = destination?.[subSchema] || {};
+            });
+          }
+          if (schema.default !== void 0) {
+            if (indexProperty !== void 0) {
+              destination[indexProperty] = schema.default;
+            }
+          }
+        }
+      }
+    );
+    if (!Object.keys(defaults).length) {
+      return {};
     }
-    setSpec(spec) {
-        this.spec = spec;
+    return {
+      // @todo should we filter out empty and undefined objects from here with `remove-undefined-objects`?
+      [payloadType]: defaults
+    };
+  }).reduce((prev, next) => Object.assign(prev, next));
+}
+
+// src/lib/parseResponse.ts
+import { matchesMimeType } from "oas/utils";
+async function parseResponse(response) {
+  const contentType = response.headers.get("Content-Type");
+  const isJSON = contentType && (matchesMimeType.json(contentType) || matchesMimeType.wildcard(contentType));
+  const responseBody = await response.text();
+  let data = responseBody;
+  if (isJSON) {
+    try {
+      data = JSON.parse(responseBody);
+    } catch (e) {
     }
-    setConfig(config) {
-        this.config = config;
-        return this;
+  }
+  return {
+    data,
+    status: response.status,
+    headers: response.headers,
+    res: response
+  };
+}
+
+// src/lib/prepareAuth.ts
+function prepareAuth(authKey, operation) {
+  if (authKey.length === 0) {
+    return {};
+  }
+  const preparedAuth = {};
+  const security = operation.getSecurity();
+  if (security.length === 0) {
+    return {};
+  }
+  if (security.every((s) => Object.keys(s).length > 1)) {
+    throw new Error(
+      "Sorry, this operation currently requires multiple forms of authentication which this library doesn't yet support."
+    );
+  }
+  const usableSecurity = security.map((s) => {
+    return Object.keys(s).length === 1 ? s : false;
+  }).filter(Boolean);
+  const usableSecuritySchemes = usableSecurity.map((s) => Object.keys(s)).reduce((prev, next) => prev.concat(next), []);
+  const preparedSecurity = operation.prepareSecurity();
+  if (authKey.length >= 2) {
+    if (!("Basic" in preparedSecurity)) {
+      throw new Error("Multiple auth tokens were supplied for this endpoint but only a single token is needed.");
+    }
+    const schemes2 = preparedSecurity.Basic.filter((s) => usableSecuritySchemes.includes(s._key));
+    if (!schemes2.length) {
+      throw new Error(
+        "Credentials for Basic Authentication were supplied but this operation requires another form of auth in that case, which this library does not yet support. This operation does, however, allow supplying a single auth token."
+      );
     }
-    setUserAgent(userAgent) {
-        this.userAgent = userAgent;
-        return this;
+    const scheme2 = schemes2.shift();
+    preparedAuth[scheme2._key] = {
+      user: authKey[0],
+      pass: authKey.length === 2 ? authKey[1] : ""
+    };
+    return preparedAuth;
+  }
+  const usableScheme = usableSecuritySchemes[0];
+  const schemes = Object.entries(preparedSecurity).map(([, ps]) => ps.filter((s) => usableScheme === s._key)).reduce((prev, next) => prev.concat(next), []);
+  const scheme = schemes.shift();
+  switch (scheme.type) {
+    case "http":
+      if (scheme.scheme === "basic") {
+        preparedAuth[scheme._key] = {
+          user: authKey[0],
+          pass: authKey.length === 2 ? authKey[1] : ""
+        };
+      } else if (scheme.scheme === "bearer") {
+        preparedAuth[scheme._key] = authKey[0];
+      }
+      break;
+    case "oauth2":
+      preparedAuth[scheme._key] = authKey[0];
+      break;
+    case "apiKey":
+      if (scheme.in === "query" || scheme.in === "header" || scheme.in === "cookie") {
+        preparedAuth[scheme._key] = authKey[0];
+      }
+      break;
+    default:
+      throw new Error(
+        `Sorry, this API currently uses a security scheme, ${scheme.type}, which this library doesn't yet support.`
+      );
+  }
+  return preparedAuth;
+}
+
+// src/lib/prepareParams.ts
+import fs from "fs";
+import path from "path";
+import stream from "stream";
+import caseless from "caseless";
+import DatauriParser from "datauri/parser.js";
+import datauri from "datauri/sync.js";
+import getStream from "get-stream";
+import lodashMerge from "lodash.merge";
+import removeUndefinedObjects from "remove-undefined-objects";
+var specialHeaders = ["accept", "authorization"];
+function digestParameters(parameters) {
+  return parameters.reduce((prev, param) => {
+    if ("$ref" in param || "allOf" in param || "anyOf" in param || "oneOf" in param) {
+      throw new Error("The OpenAPI document for this operation wasn't dereferenced before processing.");
+    } else if (param.name in prev) {
+      throw new Error(
+        `The operation you are using has the same parameter, ${param.name}, spread across multiple entry points. We unfortunately can't handle this right now.`
+      );
+    }
+    return Object.assign(prev, { [param.name]: param });
+  }, {});
+}
+function isEmpty(obj) {
+  return [Object, Array].includes((obj || {}).constructor) && !Object.entries(obj || {}).length;
+}
+function isObject(thing) {
+  if (thing instanceof stream.Readable) {
+    return false;
+  }
+  return typeof thing === "object" && thing !== null && !Array.isArray(thing);
+}
+function isPrimitive(obj) {
+  return obj === null || typeof obj === "number" || typeof obj === "string";
+}
+function merge(src, target) {
+  if (Array.isArray(target)) {
+    return target;
+  } else if (!isObject(target)) {
+    return target;
+  }
+  return lodashMerge(src, target);
+}
+function processFile(paramName, file) {
+  if (typeof file === "string") {
+    const resolvedFile = path.resolve(file);
+    return new Promise((resolve, reject) => {
+      fs.stat(resolvedFile, async (err) => {
+        if (err) {
+          if (err.code === "ENOENT") {
+            return resolve(void 0);
+          }
+          return reject(err);
+        }
+        const fileMetadata = await datauri(resolvedFile);
+        const payloadFilename = encodeURIComponent(path.basename(resolvedFile));
+        return resolve({
+          paramName,
+          base64: fileMetadata?.content?.replace(";base64", `;name=${payloadFilename};base64`),
+          filename: payloadFilename,
+          buffer: fileMetadata.buffer
+        });
+      });
+    });
+  } else if (file instanceof stream.Readable) {
+    return getStream.buffer(file).then((buffer) => {
+      const filePath = file.path;
+      const parser = new DatauriParser();
+      const base64 = parser.format(filePath, buffer).content;
+      const payloadFilename = encodeURIComponent(path.basename(filePath));
+      return {
+        paramName,
+        base64: base64?.replace(";base64", `;name=${payloadFilename};base64`),
+        filename: payloadFilename,
+        buffer
+      };
+    });
+  }
+  return Promise.reject(
+    new TypeError(
+      paramName ? `The data supplied for the \`${paramName}\` request body parameter is not a file handler that we support.` : "The data supplied for the request body payload is not a file handler that we support."
+    )
+  );
+}
+async function prepareParams(operation, body, metadata) {
+  let metadataIntersected = false;
+  const digestedParameters = digestParameters(operation.getParameters());
+  const jsonSchema = operation.getParametersAsJSONSchema();
+  metadata = removeUndefinedObjects(metadata);
+  if (!jsonSchema && (body !== void 0 || metadata !== void 0)) {
+    let throwNoParamsError = true;
+    if (body !== void 0) {
+      if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+        if (Object.keys(body).length <= 2) {
+          const bodyParams = caseless(body);
+          if (specialHeaders.some((header) => bodyParams.has(header))) {
+            throwNoParamsError = false;
+          }
+        }
+      }
     }
-    setAuth(...values) {
-        this.auth = values;
-        return this;
+    if (throwNoParamsError) {
+      throw new Error(
+        "You supplied metadata and/or body data for this operation but it doesn't have any documented parameters or request payloads. If you think this is an error please contact support for the API you're using."
+      );
     }
-    setServer(url, variables = {}) {
-        this.server = { url, variables };
-        return this;
+  }
+  const jsonSchemaDefaults = jsonSchema ? getJSONSchemaDefaults(jsonSchema) : {};
+  const params = jsonSchemaDefaults;
+  if (typeof body !== "undefined") {
+    if (Array.isArray(body) || isPrimitive(body)) {
+      params.body = merge(params.body, body);
+    } else if (typeof metadata === "undefined") {
+      const headerParams = caseless({});
+      Object.entries(digestedParameters).forEach(([paramName, param]) => {
+        if (param.in === "header") {
+          headerParams.set(paramName, "");
+        }
+      });
+      specialHeaders.forEach((header) => {
+        if (!headerParams.has(header)) {
+          headerParams.set(header, "");
+        }
+      });
+      const intersection = Object.keys(body).filter((value) => {
+        if (Object.keys(digestedParameters).includes(value)) {
+          return true;
+        } else if (headerParams.has(value)) {
+          return true;
+        }
+        return false;
+      }).length;
+      if (intersection && intersection / Object.keys(body).length > 0.25) {
+        metadataIntersected = true;
+        metadata = merge(params.body, body);
+        body = void 0;
+      } else {
+        params.body = merge(params.body, body);
+      }
+    } else {
+      params.body = merge(params.body, body);
     }
-    async fetch(path, method, body, metadata) {
-        const operation = this.spec.operation(path, method);
-        return this.fetchOperation(operation, body, metadata);
+  }
+  if (!operation.hasRequestBody()) {
+    delete params.body;
+  } else {
+    if (!("body" in params))
+      params.body = {};
+    const payloadJsonSchema = jsonSchema.find((js) => js.type === "body");
+    if (payloadJsonSchema) {
+      if (!params.files)
+        params.files = {};
+      const conversions = [];
+      if (payloadJsonSchema.schema?.properties) {
+        Object.entries(payloadJsonSchema.schema?.properties).filter(([, schema]) => schema?.format === "binary").filter(([prop]) => Object.keys(params.body).includes(prop)).forEach(([prop]) => {
+          conversions.push(processFile(prop, params.body[prop]));
+        });
+      } else if (payloadJsonSchema.schema?.type === "string") {
+        if (payloadJsonSchema.schema?.format === "binary") {
+          conversions.push(processFile(void 0, params.body));
+        }
+      }
+      await Promise.all(conversions).then((fileMetadata) => fileMetadata.filter(Boolean)).then((fm) => {
+        fm.forEach((fileMetadata) => {
+          if (!fileMetadata) {
+            return;
+          }
+          if (fileMetadata.paramName) {
+            params.body[fileMetadata.paramName] = fileMetadata.base64;
+          } else {
+            params.body = fileMetadata.base64;
+          }
+          if (fileMetadata.buffer && params?.files) {
+            params.files[fileMetadata.filename] = fileMetadata.buffer;
+          }
+        });
+      });
     }
-    async fetchOperation(operation, body, metadata) {
-        return (0, prepareParams_1.default)(operation, body, metadata).then(params => {
-            const data = { ...params };
-            // If `sdk.server()` has been issued data then we need to do some extra work to figure out
-            // how to use that supplied server, and also handle any server variables that were sent
-            // alongside it.
-            if (this.server) {
-                const preparedServer = (0, prepareServer_1.default)(this.spec, this.server.url, this.server.variables);
-                if (preparedServer) {
-                    data.server = preparedServer;
-                }
+  }
+  if (operation.isFormUrlEncoded()) {
+    params.formData = merge(params.formData, params.body);
+    delete params.body;
+  }
+  if (typeof metadata !== "undefined") {
+    if (!("cookie" in params))
+      params.cookie = {};
+    if (!("header" in params))
+      params.header = {};
+    if (!("path" in params))
+      params.path = {};
+    if (!("query" in params))
+      params.query = {};
+    Object.entries(digestedParameters).forEach(([paramName, param]) => {
+      let value;
+      let metadataHeaderParam;
+      if (typeof metadata === "object" && !isEmpty(metadata)) {
+        if (paramName in metadata) {
+          value = metadata[paramName];
+          metadataHeaderParam = paramName;
+        } else if (param.in === "header") {
+          metadataHeaderParam = Object.keys(metadata).find((k) => k.toLowerCase() === paramName.toLowerCase()) || "";
+          value = metadata[metadataHeaderParam];
+        }
+      }
+      if (value === void 0) {
+        return;
+      }
+      switch (param.in) {
+        case "path":
+          params.path[paramName] = value;
+          if (metadata?.[paramName])
+            delete metadata[paramName];
+          break;
+        case "query":
+          params.query[paramName] = value;
+          if (metadata?.[paramName])
+            delete metadata[paramName];
+          break;
+        case "header":
+          params.header[paramName.toLowerCase()] = value;
+          if (metadataHeaderParam && metadata?.[metadataHeaderParam])
+            delete metadata[metadataHeaderParam];
+          break;
+        case "cookie":
+          params.cookie[paramName] = value;
+          if (metadata?.[paramName])
+            delete metadata[paramName];
+          break;
+        default:
+      }
+      if (metadataIntersected && operation.isFormUrlEncoded()) {
+        if (paramName in params.formData) {
+          delete params.formData[paramName];
+        }
+      }
+    });
+    if (!isEmpty(metadata)) {
+      if (typeof metadata === "object") {
+        specialHeaders.forEach((headerName) => {
+          const headerParam = Object.keys(metadata || {}).find((m) => m.toLowerCase() === headerName);
+          if (headerParam) {
+            if (typeof metadata === "object") {
+              if (typeof params.header === "object") {
+                params.header[headerName] = metadata[headerParam];
+              }
+              delete metadata[headerParam];
             }
-            // @ts-expect-error `this.auth` typing is off. FIXME
-            const har = (0, oas_to_har_1.default)(this.spec, operation, data, (0, prepareAuth_1.default)(this.auth, operation));
-            let timeoutSignal;
-            const init = {};
-            if (this.config.timeout) {
-                const controller = new AbortController();
-                timeoutSignal = setTimeout(() => controller.abort(), this.config.timeout);
-                init.signal = controller.signal;
-            }
-            return (0, fetch_har_1.default)(har, {
-                files: data.files || {},
-                init,
-                userAgent: this.userAgent,
-            })
-                .then(async (res) => {
-                const parsed = await (0, parseResponse_1.default)(res);
-                if (res.status >= 400 && res.status <= 599) {
-                    throw new fetchError_1.default(parsed.status, parsed.data, parsed.headers, parsed.res);
-                }
-                return parsed;
-            })
-                .finally(() => {
-                if (this.config.timeout) {
-                    clearTimeout(timeoutSignal);
-                }
-            });
+          }
         });
+      }
+      if (operation.isFormUrlEncoded()) {
+        params.formData = merge(params.formData, metadata);
+      } else {
+      }
+    }
+  }
+  ["body", "cookie", "files", "formData", "header", "path", "query"].forEach((type) => {
+    if (type in params && isEmpty(params[type])) {
+      delete params[type];
     }
+  });
+  return params;
 }
-exports.default = APICore;
+
+// src/lib/prepareServer.ts
+function stripTrailingSlash(url) {
+  if (url[url.length - 1] === "/") {
+    return url.slice(0, -1);
+  }
+  return url;
+}
+function prepareServer(spec, url, variables = {}) {
+  let serverIdx;
+  const sanitizedUrl = stripTrailingSlash(url);
+  (spec.api.servers || []).forEach((server, i) => {
+    if (server.url === sanitizedUrl) {
+      serverIdx = i;
+    }
+  });
+  if (serverIdx) {
+    return {
+      selected: serverIdx,
+      variables
+    };
+  } else if (Object.keys(variables).length) {
+  } else {
+    const server = spec.splitVariables(url);
+    if (server) {
+      return {
+        selected: server.selected,
+        variables: server.variables
+      };
+    }
+  }
+  return false;
+}
+
+// src/index.ts
+var APICore = class {
+  spec;
+  auth = [];
+  server = false;
+  config = {};
+  userAgent;
+  constructor(spec, userAgent) {
+    if (spec)
+      this.spec = spec;
+    if (userAgent)
+      this.userAgent = userAgent;
+  }
+  setSpec(spec) {
+    this.spec = spec;
+  }
+  setConfig(config) {
+    this.config = config;
+    return this;
+  }
+  setUserAgent(userAgent) {
+    this.userAgent = userAgent;
+    return this;
+  }
+  setAuth(...values) {
+    this.auth = values;
+    return this;
+  }
+  setServer(url, variables = {}) {
+    this.server = { url, variables };
+    return this;
+  }
+  async fetch(path2, method, body, metadata) {
+    const operation = this.spec.operation(path2, method);
+    return this.fetchOperation(operation, body, metadata);
+  }
+  async fetchOperation(operation, body, metadata) {
+    return prepareParams(operation, body, metadata).then((params) => {
+      const data = { ...params };
+      if (this.server) {
+        const preparedServer = prepareServer(this.spec, this.server.url, this.server.variables);
+        if (preparedServer) {
+          data.server = preparedServer;
+        }
+      }
+      const har = oasToHar(this.spec, operation, data, prepareAuth(this.auth, operation));
+      let timeoutSignal;
+      const init = {};
+      if (this.config.timeout) {
+        const controller = new AbortController();
+        timeoutSignal = setTimeout(() => controller.abort(), this.config.timeout);
+        init.signal = controller.signal;
+      }
+      return fetchHar(har, {
+        files: data.files || {},
+        init,
+        userAgent: this.userAgent
+      }).then(async (res) => {
+        const parsed = await parseResponse(res);
+        if (res.status >= 400 && res.status <= 599) {
+          throw new FetchError(
+            parsed.status,
+            parsed.data,
+            parsed.headers,
+            parsed.res
+          );
+        }
+        return parsed;
+      }).finally(() => {
+        if (this.config.timeout) {
+          clearTimeout(timeoutSignal);
+        }
+      });
+    });
+  }
+};
+export {
+  APICore as default
+};
+//# sourceMappingURL=index.js.map