@prismatic-io/prism 4.1.1 → 4.2.2

package/lib/generate/client.js

@@ -1,93 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClient = void 0;
-const ts_morph_1 = require("ts-morph");
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const generateClient = async (project) => {
-    const { clientFile } = project;
-    if (clientFile === undefined) {
-        return;
-    }
-    clientFile.addImportDeclarations([
-        {
-            moduleSpecifier: `../${project.definitionDirectory}/core/OpenAPI`,
-            namedImports: [{ name: "EnhancedOpenAPI" }],
-        },
-        {
-            moduleSpecifier: "@prismatic-io/spectral",
-            namedImports: [
-                { name: "util" },
-                { name: "Connection" },
-                { name: "ConnectionError" },
-            ],
-        },
-        {
-            moduleSpecifier: "axios",
-            defaultImport: "Axios",
-        },
-        {
-            moduleSpecifier: "axios-retry",
-            defaultImport: "axiosRetry",
-            namedImports: [
-                { name: "IAxiosRetryConfig" },
-                { name: "exponentialDelay" },
-            ],
-        },
-    ]);
-    clientFile.addInterface({
-        name: "InitializeClientProps",
-        properties: [
-            { name: "connection", type: "Connection", hasQuestionToken: true },
-            { name: "apiBaseUrl", type: "unknown", hasQuestionToken: true },
-            { name: "debugRequest", type: "unknown", hasQuestionToken: true },
-            { name: "maxRetries", type: "unknown", hasQuestionToken: true },
-            { name: "retryDelayMS", type: "unknown", hasQuestionToken: true },
-            { name: "retryOnAllErrors", type: "unknown", hasQuestionToken: true },
-            { name: "timeout", type: "unknown", hasQuestionToken: true },
-            {
-                name: "useExponentialBackoff",
-                type: "unknown",
-                hasQuestionToken: true,
-            },
-        ],
-    });
-    clientFile.addVariableStatements([
-        {
-            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-            declarations: [
-                {
-                    name: "initializeClient",
-                    initializer: String(await fs_1.promises.readFile(path.resolve(__dirname, "..", "..", "templates", "component", "openapi", "client.ts"))),
-                },
-            ],
-            isExported: true,
-        },
-    ]);
-    clientFile.formatText();
-    await clientFile.save();
-};
-exports.generateClient = generateClient;

package/lib/generate/connection.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateConnections = void 0;
-const ts_morph_1 = require("ts-morph");
-const generateConnections = async (project) => {
-    const { connectionsFile } = project;
-    if (connectionsFile === undefined) {
-        return;
-    }
-    connectionsFile.addImportDeclarations([
-        {
-            moduleSpecifier: "@prismatic-io/spectral",
-            namedImports: [{ name: "connection" }],
-        },
-    ]);
-    const placeholder = connectionsFile.addVariableStatement({
-        declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-        declarations: [
-            { name: "connectionPlaceholder", initializer: ts_morph_1.Writers.object({}) },
-        ],
-    });
-    const object = placeholder
-        .getDeclarations()[0]
-        .getInitializer();
-    object.addPropertyAssignments([
-        {
-            name: "key",
-            initializer: `"basicAuth"`,
-        },
-        {
-            name: "label",
-            initializer: `"Example Basic Auth"`,
-        },
-        {
-            name: "comments",
-            initializer: `"Example Basic Auth comments"`,
-        },
-        {
-            name: "inputs",
-            initializer: `{
-      username: {
-        label: "Username",
-        placeholder: "Username",
-        type: "string",
-        required: true,
-        comments: "Username for auth",
-      },
-      password: {
-        label: "Password",
-        placeholder: "Password",
-        type: "password",
-        required: true,
-        comments: "Password for auth",
-      },
-    }`,
-        },
-    ]);
-    connectionsFile.addVariableStatement({
-        declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-        declarations: [
-            {
-                name: "basicAuthConnection",
-                initializer: `connection(${object.print()})`,
-            },
-        ],
-        isExported: true,
-    });
-    placeholder.remove();
-    connectionsFile.addExportAssignment({
-        isExportEquals: false,
-        expression: `[basicAuthConnection]`,
-    });
-    connectionsFile.organizeImports();
-    connectionsFile.formatText();
-    await connectionsFile.save();
-};
-exports.generateConnections = generateConnections;

package/templates/component/openapi/client.ts

@@ -1,75 +0,0 @@
-({
-  connection,
-  apiBaseUrl,
-  debugRequest,
-  maxRetries,
-  retryDelayMS,
-  retryOnAllErrors,
-  timeout,
-  useExponentialBackoff,
-}: InitializeClientProps) => {
-  if (apiBaseUrl) {
-    EnhancedOpenAPI.BASE = util.types.toString(apiBaseUrl);
-  }
-
-  EnhancedOpenAPI.timeout =
-    typeof timeout !== undefined ? util.types.toNumber(timeout) : undefined;
-
-  EnhancedOpenAPI.CLIENT = Axios.create();
-
-  if (maxRetries) {
-    const axiosRetryConfig: IAxiosRetryConfig = {
-      retries: util.types.toInt(maxRetries),
-      shouldResetTimeout: true,
-    };
-    if (retryDelayMS) {
-      // Use a specified delay.
-      axiosRetryConfig.retryDelay = () => {
-        return util.types.toInt(retryDelayMS);
-      };
-    } else if (
-      useExponentialBackoff &&
-      util.types.toBool(useExponentialBackoff)
-    ) {
-      // Use a predefined exponential backoff.
-
-      axiosRetryConfig.retryDelay = exponentialDelay;
-    }
-
-    if (retryOnAllErrors && util.types.toBool(retryOnAllErrors)) {
-      // Retry on all errors regardless of type or HTTP method.
-      axiosRetryConfig.retryCondition = () => {
-        return true;
-      };
-    }
-
-    axiosRetry(EnhancedOpenAPI.CLIENT, axiosRetryConfig);
-  }
-
-  if (util.types.toBool(debugRequest) === true) {
-    EnhancedOpenAPI.CLIENT.interceptors.request.use((request) => {
-      console.log(JSON.stringify(request));
-      return request;
-    });
-
-    EnhancedOpenAPI.CLIENT.interceptors.response.use(
-      ({ headers, status, statusText, config, data }) => {
-        console.log({ headers, status, statusText, config, data });
-        return { headers, status, statusText, config, data };
-      }
-    );
-  }
-
-  if (connection) {
-    const { key, fields } = connection;
-    if (key === "basicAuth") {
-      EnhancedOpenAPI.USERNAME = fields.username as string;
-      EnhancedOpenAPI.PASSWORD = fields.password as string;
-    } else {
-      throw new ConnectionError(
-        connection,
-        `Invalid connection type provided: ${key}`
-      );
-    }
-  }
-};

package/templates/component/openapi/request.ts

@@ -1,163 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-// @ts-ignore
-import FormData from "form-data";
-import { AxiosResponse } from "axios";
-import { util } from "@prismatic-io/spectral";
-import { types } from "util";
-// @ts-ignore
-import type { ApiRequestOptions } from "./ApiRequestOptions";
-// @ts-ignore
-import { EnhancedOpenAPI } from "./OpenAPI";
-
-function isDefined<T>(
-  value: T | null | undefined
-): value is Exclude<T, null | undefined> {
-  return value !== undefined && value !== null;
-}
-
-function isString(value: any): value is string {
-  return typeof value === "string";
-}
-
-function isStringWithValue(value: any): value is string {
-  return isString(value) && value !== "";
-}
-
-function isBinary(value: any): value is Buffer | ArrayBuffer | ArrayBufferView {
-  const isBuffer = Buffer.isBuffer(value);
-  const isArrayBuffer = types.isArrayBuffer(value);
-  const isArrayBufferView = types.isArrayBufferView(value);
-  return isBuffer || isArrayBuffer || isArrayBufferView;
-}
-
-function getUrl(options: ApiRequestOptions): string {
-  const path = options.path.replace(/[:]/g, "_");
-  const url = `${EnhancedOpenAPI.BASE}${path}`;
-
-  return url;
-}
-
-function getFormData(params: Record<string, any>): FormData {
-  const formData = new FormData();
-  Object.entries(params).forEach(([key, value]) => {
-    if (isDefined(value)) {
-      formData.append(key, value);
-    }
-  });
-  return formData;
-}
-
-type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
-
-async function resolve<T>(
-  options: ApiRequestOptions,
-  resolver?: T | Resolver<T>
-): Promise<T | undefined> {
-  if (typeof resolver === "function") {
-    return (resolver as Resolver<T>)(options);
-  }
-  return resolver;
-}
-
-async function getHeaders(options: ApiRequestOptions): Promise<any> {
-  const [token, username, password, defaultHeaders] = await Promise.all([
-    resolve(options, EnhancedOpenAPI.TOKEN),
-    resolve(options, EnhancedOpenAPI.USERNAME),
-    resolve(options, EnhancedOpenAPI.PASSWORD),
-    resolve(options, EnhancedOpenAPI.HEADERS),
-  ]);
-
-  const headers: Record<string, string | number> = {
-    Accept: "application/json",
-    ...defaultHeaders,
-    ...options.headers,
-  };
-
-  if (EnhancedOpenAPI.timeout) {
-    headers["timeout"] = util.types.toInt(EnhancedOpenAPI.timeout);
-  }
-
-  if (isStringWithValue(token)) {
-    headers["Authorization"] = `Bearer ${token}`;
-  }
-
-  if (isStringWithValue(username) && isStringWithValue(password)) {
-    const credentials = Buffer.from(`${username}:${password}`).toString(
-      "base64"
-    );
-    headers["Authorization"] = `Basic ${credentials}`;
-  }
-
-  if (options.body) {
-    if (isBinary(options.body)) {
-      headers["Content-Type"] = "application/octet-stream";
-    } else if (isString(options.body)) {
-      headers["Content-Type"], "text/plain";
-    } else {
-      headers["Content-Type"] = "application/json";
-    }
-  }
-
-  return headers;
-}
-
-function getRequestBody(options: ApiRequestOptions) {
-  if (options.formData) {
-    return getFormData(options.formData);
-  }
-  if (options.body) {
-    if (isString(options.body) || isBinary(options.body)) {
-      return options.body;
-    } else {
-      return JSON.stringify(options.body);
-    }
-  }
-  return undefined;
-}
-interface RequestProps {
-  options: ApiRequestOptions;
-  url: string;
-}
-
-async function sendRequest({
-  options,
-  url,
-}: RequestProps): Promise<Partial<AxiosResponse>> {
-  if (!EnhancedOpenAPI.CLIENT) {
-    throw new Error("Client was not initialized.");
-  }
-
-  const result = await EnhancedOpenAPI.CLIENT.request({
-    url,
-    method: options.method,
-    headers: await getHeaders(options),
-    data: getRequestBody(options),
-    params: options.query ? { ...options.query } : undefined,
-  });
-
-  return result;
-}
-
-/**
- * Request using Axios client
- * @param options The request options from the the service
- * @returns Partial<AxiosResponse> & {
-    body: AxiosResponse["data"];
-  }
- */
-export async function request(options: ApiRequestOptions): Promise<
-  Partial<AxiosResponse> & {
-    body: AxiosResponse["data"];
-  }
-> {
-  const url = getUrl(options);
-
-  const response = await sendRequest({
-    options,
-    url,
-  });
-
-  return { ...response, body: await response.data };
-}