@prismatic-io/spectral 7.10.0 → 8.0.0-preview11

package/dist/clients/http/index.d.ts

@@ -162,7 +162,7 @@ export declare const buildRawRequestAction: (baseUrl: string, label?: string, de
         type: "connection";
         required: true;
     };
-}, boolean, {
+}, import("../..").ConfigVarResultCollection, boolean, {
     data: any;
 }>;
 export { inputs };

package/dist/clients/soap/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./utils";

package/dist/clients/soap/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/clients/soap/types.d.ts

@@ -0,0 +1,71 @@
+import { Connection } from "../../index";
+import { IMTOMAttachments } from "soap";
+/**
+ * SOAPConnection takes standard connection fields, and adds an optional `wsdlDefinitionUrl` field.
+ */
+export interface SOAPConnection extends Connection {
+    fields: {
+        [key: string]: unknown;
+        wsdlDefinitionUrl?: string;
+    };
+}
+/**
+ * This function determines if the object presented is a SOAP connection with a `wsdlDefinitionUrl` field.
+ * @param connection The connection to test
+ * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
+ */
+export declare const isSOAPConnection: (connection: unknown) => connection is SOAPConnection;
+/**
+ * SOAP requests return a 4-tuple or 5-tuple with the response first, the XML response second, headers third, and the XML request fourth, and optional message attachments fifth.
+ */
+export declare type SOAPResponse = [any, any, any, any, IMTOMAttachments?];
+/**
+ * Overload the `soapRequest` function to take a variety of types of arguments.
+ */
+export interface SOAPRequest {
+    (params: RequestParams): Promise<SOAPResponse>;
+    (params: RequestParams, methodParams: Record<string, unknown>): Promise<SOAPResponse>;
+    (params: RequestParams, methodParams: undefined): Promise<SOAPResponse>;
+}
+export interface RequestParams {
+    wsdlParam: SOAPConnection | string;
+    method: string;
+    overrides?: ClientOverrides;
+    debug?: boolean;
+}
+export interface ClientOverrides {
+    endpointURL?: string;
+    soapHeaders?: unknown[];
+}
+export interface HeaderPayload {
+    [x: string]: any;
+}
+export interface GenerateHeader {
+    (wsdlParam: SOAPConnection | string, headerPayload: HeaderPayload, headerOptions: undefined): Promise<string>;
+    (wsdlParam: SOAPConnection | string, headerPayload: HeaderPayload, headerOptions: {
+        namespace: string;
+        xmlns: string;
+    }): Promise<string>;
+}
+export interface BasicAuthConnection extends Connection {
+    fields: {
+        [key: string]: unknown;
+        username: unknown;
+        password: unknown;
+        loginMethod: unknown;
+    };
+}
+/**
+ * This function determines if the object presented is a Basic Auth connection with `username`, `password`, and `loginMethod` fields.
+ * @param connection The connection to test
+ * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
+ */
+export declare const isBasicAuthConnection: (connection: Connection) => connection is BasicAuthConnection;
+export interface SOAPAuth {
+    (connection: BasicAuthConnection, wsdlDefinition: string): Promise<any>;
+    (connection: BasicAuthConnection & SOAPConnection): Promise<any>;
+}
+export interface DescribeWSDL {
+    (connection: SOAPConnection): Promise<any>;
+    (wsdlDefinition: string): Promise<any>;
+}

package/dist/clients/soap/types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBasicAuthConnection = exports.isSOAPConnection = void 0;
+/**
+ * This function determines if the object presented is a SOAP connection with a `wsdlDefinitionUrl` field.
+ * @param connection The connection to test
+ * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
+ */
+const isSOAPConnection = (connection) => {
+    if (typeof connection === "object" && connection !== null)
+        return "wsdlDefinitionURL" in (connection === null || connection === void 0 ? void 0 : connection.fields);
+    return false;
+};
+exports.isSOAPConnection = isSOAPConnection;
+/**
+ * This function determines if the object presented is a Basic Auth connection with `username`, `password`, and `loginMethod` fields.
+ * @param connection The connection to test
+ * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
+ */
+const isBasicAuthConnection = (connection) => {
+    const { fields } = connection;
+    return ("username" in fields && "password" in fields && "loginMethod" in fields);
+};
+exports.isBasicAuthConnection = isBasicAuthConnection;

package/dist/clients/soap/utils.d.ts

@@ -0,0 +1,12 @@
+import { ClientOverrides, GenerateHeader, SOAPAuth, SOAPConnection, SOAPRequest, DescribeWSDL } from "./types";
+import { Client } from "soap";
+declare const _default: {
+    describeWSDL: DescribeWSDL;
+    generateHeader: GenerateHeader;
+    getSOAPAuth: SOAPAuth;
+    getSOAPClient: <T extends string | SOAPConnection = string | SOAPConnection>(wsdlParam: T) => Promise<Client>;
+    getWSDL: (wsdlDefinitionURL: string) => Promise<string>;
+    overrideClientDefaults: (client: Client, overrides: ClientOverrides) => void;
+    soapRequest: SOAPRequest;
+};
+export default _default;

package/dist/clients/soap/utils.js

@@ -0,0 +1,191 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const types_1 = require("./types");
+const index_1 = require("../../index");
+const soap_1 = require("soap");
+const axios_1 = __importDefault(require("axios"));
+const promises_1 = require("fs/promises");
+const uuid_1 = require("uuid");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Optionally log out SOAP requests and responses for debugging purposes
+ *
+ * @param client A SOAP client that generates requests and responses
+ */
+const debugRequest = (client) => {
+    console.debug(client.lastRequest);
+    console.debug(client.lastResponse);
+};
+/**
+ * This function takes either the URL of a WSDL or the XML defining a WSDL, and returns an object describing the methods and attributes defined in the WSDL.
+ *
+ * @param wsdlParam Either the URL where a WSDL is stored, or the XML defining a WSDL.
+ * @returns An object containing the methods and attributes defined in a WSDL
+ */
+const describeWSDL = (wsdlParam) => __awaiter(void 0, void 0, void 0, function* () {
+    const client = yield getSOAPClient((0, types_1.isSOAPConnection)(wsdlParam) ? wsdlParam : index_1.util.types.toString(wsdlParam));
+    try {
+        const result = client.describe();
+        return result;
+    }
+    catch (error) {
+        throw new Error("Unable to parse WSDL Services due to circular references");
+    }
+});
+/**
+ * Fetch a WSDL from a URL
+ * @param wsdlDefinitionURL The URL where the WSDL is stored
+ * @returns The WSDL's raw XML
+ */
+const getWSDL = (wsdlDefinitionURL) => __awaiter(void 0, void 0, void 0, function* () {
+    const httpClient = axios_1.default.create({
+        baseURL: wsdlDefinitionURL,
+        headers: { "Content-Type": "text/xml" },
+    });
+    const { data } = yield httpClient.get("");
+    return index_1.util.types.toString(data);
+});
+/**
+ * Create a SOAP client given a WSDL or SOAPConnection
+ * @param wsdlParam a SOAPConnection or XML defining a WSDL
+ * @returns An HTTP client configured to query a SOAP-based API
+ */
+const getSOAPClient = (wsdlParam) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof wsdlParam === "string") {
+        const wsdl = index_1.util.types.toString(wsdlParam);
+        const filePath = path_1.default.join(os_1.default.tmpdir(), `${(0, uuid_1.v4)()}.wsdl`);
+        yield (0, promises_1.writeFile)(filePath, wsdl);
+        const client = yield (0, soap_1.createClientAsync)(filePath);
+        yield (0, promises_1.rm)(filePath);
+        return client;
+    }
+    else if ((0, types_1.isSOAPConnection)(wsdlParam)) {
+        const { fields: { wsdlDefinitionURL }, } = wsdlParam;
+        if (!wsdlDefinitionURL ||
+            !index_1.util.types.isUrl(index_1.util.types.toString(wsdlDefinitionURL))) {
+            throw new Error("WSDL Definition or the Connection field 'wsdlDefinitionURL' must be supplied.");
+        }
+        const client = yield (0, soap_1.createClientAsync)(index_1.util.types.toString(wsdlDefinitionURL));
+        return client;
+    }
+    else {
+        throw new Error("WSDL Definition or the Connection field 'wsdlDefinitionURL' must be supplied.");
+    }
+});
+/**
+ * Override some HTTP client defaults
+ * @param client The client to override
+ * @param overrides An endpoint URL or SOAP headers to override
+ */
+const overrideClientDefaults = (client, overrides) => {
+    const { endpointURL, soapHeaders } = overrides;
+    if (endpointURL) {
+        client.setEndpoint(endpointURL);
+    }
+    if (soapHeaders) {
+        soapHeaders.map((header) => {
+            client.addSoapHeader(header);
+        });
+    }
+};
+/**
+ * Make a request to a SOAP-based API
+ * @param param0
+ * @param methodParams Parameters to pass to the specified SOAP method
+ * @returns The results from the SOAP request, including the full XML of the request and response
+ */
+const soapRequest = ({ wsdlParam, method, overrides, debug }, methodParams) => __awaiter(void 0, void 0, void 0, function* () {
+    const client = yield getSOAPClient((0, types_1.isSOAPConnection)(wsdlParam) ? wsdlParam : index_1.util.types.toString(wsdlParam));
+    if (overrides) {
+        overrideClientDefaults(client, overrides);
+    }
+    const requestFunction = client[`${method}Async`];
+    let results = undefined;
+    try {
+        if (typeof methodParams === "object" && methodParams !== null) {
+            results = yield requestFunction(methodParams);
+        }
+        else {
+            results = yield requestFunction({});
+        }
+        if (index_1.util.types.isBool(debug) && debug) {
+            debugRequest(client);
+        }
+        return results;
+    }
+    catch (error) {
+        if (index_1.util.types.isBool(debug) && debug) {
+            debugRequest(client);
+        }
+        console.warn("Please verify that the method you specified exists in the WSDL specification.");
+        throw error;
+    }
+});
+/**
+ * Create a SOAP header
+ * @param wsdlParam A SOAPConnection or XML definition of a WSDL
+ * @param headerPayload The contents of a header XML node
+ * @param headerOptions Attributes for a header XML node, like namespace or xmlns
+ * @returns
+ */
+const generateHeader = (wsdlParam, headerPayload, headerOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    const client = yield getSOAPClient((0, types_1.isSOAPConnection)(wsdlParam) ? wsdlParam : index_1.util.types.toString(wsdlParam));
+    let options = [];
+    if (headerOptions) {
+        options = Object.values(headerOptions);
+    }
+    const index = client.addSoapHeader(headerPayload, "", ...options);
+    return client.getSoapHeaders()[index];
+});
+/**
+ * Fetch authentication information for a SOAPConnection
+ * @param connection The SOAPConnection
+ * @param wsdlDefinition The XML WSDL definition
+ * @returns
+ */
+const getSOAPAuth = (connection, wsdlDefinition) => __awaiter(void 0, void 0, void 0, function* () {
+    if ((0, types_1.isBasicAuthConnection)(connection) && wsdlDefinition) {
+        const { fields: { username, password, loginMethod }, } = connection;
+        const result = yield soapRequest({
+            wsdlParam: index_1.util.types.toString(wsdlDefinition),
+            method: index_1.util.types.toString(loginMethod),
+        }, { username, password });
+        return result;
+    }
+    else if ((0, types_1.isSOAPConnection)(connection) &&
+        (0, types_1.isBasicAuthConnection)(connection)) {
+        const { fields: { username, password, loginMethod }, } = connection;
+        const result = yield soapRequest({
+            wsdlParam: connection,
+            method: index_1.util.types.toString(loginMethod),
+        }, { username, password });
+        return result;
+    }
+    else {
+        throw new Error("Must supply a SOAP Connection or a WSDL Definition");
+    }
+});
+exports.default = {
+    describeWSDL,
+    generateHeader,
+    getSOAPAuth,
+    getSOAPClient,
+    getWSDL,
+    overrideClientDefaults,
+    soapRequest,
+};

package/dist/index.d.ts

@@ -3,8 +3,45 @@
  * authors create inputs, actions, and components that can
  * be processed by the Prismatic API.
  */
-import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition } from "./types";
-import { convertComponent } from "./serverTypes/convert";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition, IntegrationDefinition, Flow, ConfigPage, StandardConfigVar, ConnectionConfigVar, ConfigVar, ConfigVarResultCollection, ConfigVarCollection, TriggerPayload } from "./types";
+import { convertComponent, convertIntegration } from "./serverTypes/convert";
+/**
+ * This function creates a Integration object that can be
+ * imported into the Prismatic API. For information on using
+ * this function to write code native integrations, see
+ * https://prismatic.io/docs/code-native-integrations/.
+ * @param definition An IntegrationDefinition type object.
+ * @returns This function returns an integration object that has the shape the Prismatic API expects.
+ */
+export declare const integration: <TConfigVar extends Record<string, ConfigVar> = Record<string, ConfigVar>>(definition: IntegrationDefinition<TConfigVar>) => ReturnType<typeof convertIntegration>;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-flows.
+ * @param definition A Flow type object.
+ * @returns This function returns a flow object that has the shape the Prismatic API expects.
+ */
+export declare const flow: <TConfigVars extends ConfigVarCollection = ConfigVarCollection, TTriggerPayload extends TriggerPayload = TriggerPayload, T extends Flow<TConfigVars, TTriggerPayload> = Flow<TConfigVars, TTriggerPayload>>(definition: T) => T;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-pages.
+ * @param definition A Config Page type object.
+ * @returns This function returns a config page object that has the shape the Prismatic API expects.
+ */
+export declare const configPage: <T extends ConfigPage<ConfigVarCollection>>(definition: T) => T;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
+ * @param definition A Config Var type object.
+ * @returns This function returns a standard config var object that has the shape the Prismatic API expects.
+ */
+export declare const configVar: <T extends StandardConfigVar>(definition: T) => T;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
+ * @param definition A Connection Config Var type object.
+ * @returns This function returns a connection config var object that has the shape the Prismatic API expects.
+ */
+export declare const connectionConfigVar: <T extends ConnectionConfigVar>(definition: T) => T;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using
@@ -23,7 +60,7 @@ export declare const component: <TPublic extends boolean, TKey extends string>(d
  * @param definition An ActionDefinition type object that includes UI display information, a function to perform when the action is invoked, and a an object containing inputs for the perform function.
  * @returns This function validates the shape of the `definition` object provided, and returns the same action object.
  */
-export declare const action: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, TAllowsBranching, TReturn>;
+export declare const action: <TInputs extends Inputs, TConfigVar extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TConfigVar, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, TConfigVar, TAllowsBranching, TReturn>;
 /**
  * This function creates a trigger object that can be referenced
  * by a custom component. It helps ensure that the shape of the
@@ -33,7 +70,7 @@ export declare const action: <TInputs extends Inputs, TAllowsBranching extends b
  * @param definition A TriggerDefinition type object that includes UI display information, a function to perform when the trigger is invoked, and a an object containing inputs for the perform function.
  * @returns This function validates the shape of the `definition` object provided, and returns the same trigger object.
  */
-export declare const trigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>>(definition: TriggerDefinition<TInputs, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TAllowsBranching, TResult>;
+export declare const trigger: <TInputs extends Inputs, TConfigVar extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>>(definition: TriggerDefinition<TInputs, TConfigVar, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TConfigVar, TAllowsBranching, TResult>;
 /**
  * This function creates a data source object that can be referenced
  * by a custom component. It helps ensure that the shape of the
@@ -56,14 +93,6 @@ export declare const dataSource: <TInputs extends Inputs, TDataSourceType extend
     boolean: boolean;
     number: number;
     connection: import("./types").Connection;
-    /**
-     * This function creates a component object that can be
-     * imported into the Prismatic API. For information on using
-     * this function to write custom components, see
-     * https://prismatic.io/docs/custom-components/writing-custom-components/#exporting-a-component.
-     * @param definition A ComponentDefinition type object, including display information, unique key, and a set of actions the component implements.
-     * @returns This function returns a component object that has the shape the Prismatic API expects.
-     */
     objectSelection: import("./types").ObjectSelection;
     objectFieldMap: import("./types").ObjectFieldMap;
     jsonForm: import("./types").JSONForm;

package/dist/index.js

@@ -22,8 +22,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = void 0;
+exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = exports.connectionConfigVar = exports.configVar = exports.configPage = exports.flow = exports.integration = void 0;
 const convert_1 = require("./serverTypes/convert");
+/**
+ * This function creates a Integration object that can be
+ * imported into the Prismatic API. For information on using
+ * this function to write code native integrations, see
+ * https://prismatic.io/docs/code-native-integrations/.
+ * @param definition An IntegrationDefinition type object.
+ * @returns This function returns an integration object that has the shape the Prismatic API expects.
+ */
+const integration = (definition) => (0, convert_1.convertIntegration)(definition);
+exports.integration = integration;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-flows.
+ * @param definition A Flow type object.
+ * @returns This function returns a flow object that has the shape the Prismatic API expects.
+ */
+const flow = (definition) => definition;
+exports.flow = flow;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-pages.
+ * @param definition A Config Page type object.
+ * @returns This function returns a config page object that has the shape the Prismatic API expects.
+ */
+const configPage = (definition) => definition;
+exports.configPage = configPage;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
+ * @param definition A Config Var type object.
+ * @returns This function returns a standard config var object that has the shape the Prismatic API expects.
+ */
+const configVar = (definition) => definition;
+exports.configVar = configVar;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
+ * @param definition A Connection Config Var type object.
+ * @returns This function returns a connection config var object that has the shape the Prismatic API expects.
+ */
+const connectionConfigVar = (definition) => definition;
+exports.connectionConfigVar = connectionConfigVar;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using

package/dist/serverTypes/convert.d.ts

@@ -1,3 +1,4 @@
-import { ComponentDefinition } from "../types";
+import { ComponentDefinition, IntegrationDefinition } from "../types";
 import { Component as ServerComponent } from ".";
 export declare const convertComponent: <TPublic extends boolean, TKey extends string>({ connections, actions, triggers, dataSources, hooks, ...definition }: ComponentDefinition<TPublic, TKey>) => ServerComponent;
+export declare const convertIntegration: (definition: IntegrationDefinition) => ServerComponent;