@prismatic-io/spectral 5.0.0-rc.3 → 5.2.0

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,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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,67 @@
+import { Connection } from "../../index";
+import { Client, IMTOMAttachments } from "soap";
+export interface SOAPConnection extends Connection {
+    fields: {
+        [key: string]: unknown;
+        wsdlDefinitionUrl?: string;
+    };
+}
+export declare const isSOAPConnection: (connection: unknown) => connection is SOAPConnection;
+export interface GetClient {
+    (connection: SOAPConnection): Promise<Client>;
+    (wsdlDefinition: string): Promise<Client>;
+}
+export interface SOAPRequest {
+    (params: RequestParams): Promise<[any, any, any, any, IMTOMAttachments?]>;
+    (params: RequestParams, methodParams: Record<string, unknown>): Promise<[
+        any,
+        any,
+        any,
+        any,
+        IMTOMAttachments?
+    ]>;
+    (params: RequestParams, methodParams: undefined): Promise<[
+        any,
+        any,
+        any,
+        any,
+        IMTOMAttachments?
+    ]>;
+}
+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;
+    };
+}
+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,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBasicAuthConnection = exports.isSOAPConnection = void 0;
+const isSOAPConnection = (connection) => {
+    var _a;
+    if (typeof connection === "object" && connection !== null)
+        return "wsdlDefinitionURL" in ((_a = connection) === null || _a === void 0 ? void 0 : _a.fields);
+    return false;
+};
+exports.isSOAPConnection = isSOAPConnection;
+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,13 @@
+import { ClientOverrides, GenerateHeader, GetClient, SOAPAuth, SOAPRequest, DescribeWSDL } from "./types";
+import { Client } from "soap";
+export declare const describeWSDL: DescribeWSDL;
+declare const _default: {
+    generateHeader: GenerateHeader;
+    getSOAPClient: GetClient;
+    getSOAPAuth: SOAPAuth;
+    getWSDL: (wsdlDefinitionURL: string) => Promise<string>;
+    overrideClientDefaults: (client: Client, overrides: ClientOverrides) => void;
+    soapRequest: SOAPRequest;
+    describeWSDL: DescribeWSDL;
+};
+export default _default;

package/dist/clients/soap/utils.js

@@ -0,0 +1,165 @@
+"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 });
+exports.describeWSDL = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* 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 debugRequest = (client) => {
+    console.debug(client.lastRequest);
+    console.debug(client.lastResponse);
+};
+const describeWSDL = (wsdlParam) => __awaiter(void 0, void 0, void 0, function* () {
+    let client;
+    if (types_1.isSOAPConnection(wsdlParam)) {
+        client = yield getSOAPClient(wsdlParam);
+    }
+    else {
+        client = yield getSOAPClient(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");
+    }
+});
+exports.describeWSDL = describeWSDL;
+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);
+});
+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 = `/tmp/${uuid_1.v4()}.wsdl`;
+        yield promises_1.writeFile(filePath, wsdl);
+        const client = yield soap_1.createClientAsync(filePath);
+        yield promises_1.rm(filePath);
+        return client;
+    }
+    else if (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 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.");
+    }
+});
+const overrideClientDefaults = (client, overrides) => {
+    const { endpointURL, soapHeaders } = overrides;
+    if (endpointURL) {
+        client.setEndpoint(endpointURL);
+    }
+    if (soapHeaders) {
+        soapHeaders.map((header) => {
+            client.addSoapHeader(header);
+        });
+    }
+};
+const soapRequest = ({ wsdlParam, method, overrides, debug }, methodParams) => __awaiter(void 0, void 0, void 0, function* () {
+    let client;
+    if (types_1.isSOAPConnection(wsdlParam)) {
+        client = yield getSOAPClient(wsdlParam);
+    }
+    else {
+        client = yield getSOAPClient(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);
+        }
+        throw error;
+    }
+});
+const generateHeader = (wsdlParam, headerPayload, headerOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    let client;
+    if (types_1.isSOAPConnection(wsdlParam)) {
+        client = yield getSOAPClient(wsdlParam);
+    }
+    else {
+        client = yield getSOAPClient(wsdlParam);
+    }
+    let options = [];
+    if (headerOptions) {
+        options = Object.values(headerOptions);
+    }
+    const index = client.addSoapHeader(headerPayload, "", ...options);
+    return client.getSoapHeaders()[index];
+});
+const getSOAPAuth = (connection, wsdlDefinition) => __awaiter(void 0, void 0, void 0, function* () {
+    if (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 (types_1.isSOAPConnection(connection) &&
+        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 = {
+    generateHeader,
+    getSOAPClient,
+    getSOAPAuth,
+    getWSDL,
+    overrideClientDefaults,
+    soapRequest,
+    describeWSDL: exports.describeWSDL,
+};

package/dist/testing.js

@@ -28,6 +28,8 @@ exports.createConnection = createConnection;
  * See https://prismatic.io/docs/custom-components/writing-custom-components/#verifying-correct-logging-in-action-tests for information on testing correct logging behavior in your custom component.
  */
 const loggerMock = () => ({
+    metric: console.log,
+    trace: jest_mock_1.spyOn(console, "trace"),
     debug: jest_mock_1.spyOn(console, "debug"),
     info: jest_mock_1.spyOn(console, "info"),
     log: jest_mock_1.spyOn(console, "log"),
@@ -43,7 +45,7 @@ exports.loggerMock = loggerMock;
  */
 const invoke = (actionBase, params, context) => __awaiter(void 0, void 0, void 0, function* () {
     const action = (actionBase.perform ? actionBase : Object.values(actionBase)[0]);
-    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
     const result = yield action.perform(realizedContext, params);
     return {
         result,
@@ -88,7 +90,7 @@ exports.defaultTriggerPayload = defaultTriggerPayload;
  */
 const invokeTrigger = (triggerBase, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
     const trigger = (triggerBase.perform ? triggerBase : Object.values(triggerBase)[0]);
-    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
     const realizedPayload = Object.assign(Object.assign({}, exports.defaultTriggerPayload()), payload);
     const realizedParams = params || {};
     const result = yield trigger.perform(realizedContext, realizedPayload, realizedParams);

package/dist/types/ActionDefinition.d.ts

@@ -12,6 +12,8 @@ export interface ActionDefinition<T extends Inputs, AllowsBranching extends bool
     inputs: T;
     /** Optional attribute that specifies whether an Action will terminate execution.*/
     terminateExecution?: boolean;
+    /** Specifies whether an Action will break out of a loop. */
+    breakLoop?: boolean;
     /** Determines whether an Action will allow Conditional Branching.*/
     allowsBranching?: AllowsBranching;
     /** Static Branch names associated with an Action. */

package/dist/types/ActionLogger.d.ts

@@ -12,6 +12,8 @@ export declare type ActionLoggerFunction = (...args: unknown[]) => void;
  * An object containing logger functions.
  */
 export interface ActionLogger {
+    metric: ActionLoggerFunction;
+    trace: ActionLoggerFunction;
     debug: ActionLoggerFunction;
     info: ActionLoggerFunction;
     log: ActionLoggerFunction;

package/dist/types/ActionPerformFunction.d.ts

@@ -7,6 +7,8 @@ export interface ActionContext {
     logger: ActionLogger;
     /** A key/value store that may be used to store small amounts of data that is persisted between Instance executions */
     instanceState: Record<string, unknown>;
+    /** A key/value store that may be used to store small amounts of data for use later during the execution */
+    executionState: Record<string, unknown>;
     /** A unique id that corresponds to the step on the Integration */
     stepId: string;
     /** A unique id that corresponds to the specific execution of the Integration */

package/dist/types/ActionPerformReturn.d.ts

@@ -7,7 +7,9 @@ export interface ActionPerformDataReturn<ReturnData> {
     /** The HTTP Status code that will be used if this terminates a synchronous invocation  */
     statusCode?: number;
     /** An optional object, the keys and values of which will be persisted in the instanceState and available for subsequent actions and executions */
-    state?: Record<string, unknown>;
+    instanceState?: Record<string, unknown>;
+    /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
+    executionState?: Record<string, unknown>;
 }
 /** Used to represent a branching return of conventional data and does not require content type to be specified */
 /** Used to represent a binary or serialized data branching return as content type must be specified */

package/dist/types/DisplayDefinition.d.ts

@@ -9,8 +9,8 @@ interface DisplayDefinition {
     description: string;
 }
 interface ExtraDisplayDefinitionFields {
-    /** Path to icon to use for this Component. Path should be relative to component roto index. */
-    iconPath?: string;
+    /** Path to icon to use for this Component. Path should be relative to the built component source. */
+    iconPath: string;
     /** Category of the Component. */
     category?: string;
 }

package/dist/types/Inputs.d.ts

@@ -3,7 +3,7 @@ export declare type Inputs = Record<string, InputFieldDefinition>;
 export declare type ConnectionInput = DefaultInputFieldDefinition & {
     shown?: boolean;
 };
-export declare type InputFieldDefinition = DefaultInputFieldDefinition | CodeInputFieldDefinition;
+export declare type InputFieldDefinition = DefaultInputFieldDefinition | CodeInputFieldDefinition | ConditionalInputField | ConnectionInputField;
 interface BaseInputFieldDefinition {
     /** Interface label of the InputField. */
     label: string;
@@ -24,13 +24,21 @@ interface BaseInputFieldDefinition {
 }
 /** Defines attributes of a InputField. */
 export interface DefaultInputFieldDefinition extends BaseInputFieldDefinition {
-    type: Exclude<InputFieldType, "code">;
+    type: Exclude<InputFieldType, "code" | "conditional" | "connection">;
 }
 /** Defines attributes of a CodeInputField. */
 export interface CodeInputFieldDefinition extends BaseInputFieldDefinition {
     type: Extract<InputFieldType, "code">;
     language?: string;
 }
+/** Defines attributes of a ConditionalInputField. */
+export interface ConditionalInputField extends BaseInputFieldDefinition {
+    type: Extract<InputFieldType, "conditional">;
+}
+/** Defines attributes of a ConnectionInputField. */
+export interface ConnectionInputField extends BaseInputFieldDefinition {
+    type: Extract<InputFieldType, "connection">;
+}
 export interface Connection {
     /** Key of the Connection type. */
     key: string;

package/dist/types/TriggerDefinition.d.ts

@@ -19,6 +19,8 @@ export interface TriggerDefinition<T extends Inputs, AllowsBranching extends boo
     synchronousResponseSupport: TriggerOptionChoice;
     /** Optional attribute that specifies whether this Trigger will terminate execution. */
     terminateExecution?: boolean;
+    /** Specifies whether an Action will break out of a loop. */
+    breakLoop?: boolean;
     /** Determines whether this Trigger allows Conditional Branching. */
     allowsBranching?: AllowsBranching;
     /** Static Branch names associated with this Trigger. */

package/dist/types/TriggerResult.d.ts

@@ -7,7 +7,9 @@ export interface TriggerBaseResult {
     /** Optional HTTP response to the request that invoked the integration. */
     response?: HttpResponse;
     /** An optional object, the keys and values of which will be persisted in the instanceState and available for subsequent actions and executions */
-    state?: Record<string, unknown>;
+    instanceState?: Record<string, unknown>;
+    /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
+    executionState?: Record<string, unknown>;
 }
 /** Represents the result of a Trigger action that uses branching. */
 export interface TriggerBranchingResult extends TriggerBaseResult {

package/dist/types/server-types.d.ts

@@ -45,6 +45,8 @@ interface BaseAction {
     inputs: InputField[];
     /** Optional attribute that specifies whether an Action will terminate execution. */
     terminateExecution?: boolean;
+    /** Specifies whether an Action will break out of a loop. */
+    breakLoop?: boolean;
     /** Determines whether an Action will allow Conditional Branching. */
     allowsBranching?: boolean;
     /** Static Branch names associated with an Action. */
@@ -95,7 +97,9 @@ export interface ServerPerformDataStructureReturn {
     /** The HTTP Status code that will be used if this terminates a synchronous invocation  */
     statusCode?: number;
     /** An optional object, the keys and values of which will be persisted in the instanceState and available for subsequent actions and executions */
-    state?: Record<string, unknown>;
+    instanceState?: Record<string, unknown>;
+    /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
+    executionState?: Record<string, unknown>;
 }
 /** Used to represent a binary or serialized data return as content type must be specified */
 interface ServerPerformDataReturn {
@@ -106,7 +110,9 @@ interface ServerPerformDataReturn {
     /** The HTTP Status code that will be used if this terminates a synchronous invocation  */
     statusCode?: number;
     /** An optional object, the keys and values of which will be persisted in the instanceState and available for subsequent actions and executions */
-    state?: Record<string, unknown>;
+    instanceState?: Record<string, unknown>;
+    /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
+    executionState?: Record<string, unknown>;
 }
 /** Used to represent a branching return of conventional data and does not require content type to be specified */
 export interface ServerPerformBranchingDataStructureReturn extends ServerPerformDataStructureReturn {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "5.0.0-rc.3",
+  "version": "5.2.0",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"
@@ -32,13 +32,19 @@
     "dist/"
   ],
   "dependencies": {
+    "axios": "0.24.0",
     "date-fns": "2.17.0",
     "jest-mock": "27.0.3",
+    "soap": "0.43.0",
+    "uuid": "8.3.1",
     "valid-url": "1.0.9"
   },
   "devDependencies": {
+    "@types/axios": "0.14.0",
     "@types/jest": "26.0.23",
     "@types/node": "14.14.35",
+    "@types/sax": "1.2.4",
+    "@types/uuid": "8.3.1",
     "@types/valid-url": "1.0.3",
     "@typescript-eslint/eslint-plugin": "4.27.0",
     "@typescript-eslint/parser": "4.27.0",