@prismatic-io/spectral 6.4.0 → 6.5.1

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

@@ -1,13 +1,159 @@
+import { AxiosResponse } from "axios";
 import { AxiosInstance, AxiosRequestConfig } from "axios";
 import { IAxiosRetryConfig } from "axios-retry";
+import { ActionInputParameters } from "../../types";
+import { inputs } from "./inputs";
 export declare type HttpClient = AxiosInstance;
+interface RetryConfig extends Omit<IAxiosRetryConfig, "retryDelay"> {
+    retryDelay?: IAxiosRetryConfig["retryDelay"] | number;
+    retryAllErrors?: boolean;
+    useExponentialBackoff?: boolean;
+}
 export interface ClientProps {
     baseUrl?: string;
     responseType?: AxiosRequestConfig["responseType"];
     headers?: AxiosRequestConfig["headers"];
     timeout?: number;
     debug?: boolean;
-    retryConfig?: IAxiosRetryConfig;
+    retryConfig?: RetryConfig;
 }
 export declare const createClient: ({ baseUrl, responseType, headers, timeout, debug, retryConfig, }: ClientProps) => HttpClient;
 export declare const handleErrors: (error: unknown) => unknown;
+declare type SendRawRequestValues = ActionInputParameters<typeof inputs>;
+export declare const sendRawRequest: (baseUrl: string, values: SendRawRequestValues, authorizationHeaders?: Record<string, string>) => Promise<AxiosResponse>;
+export declare const buildRawRequestAction: (baseUrl: string, label?: string, description?: string) => import("../..").ActionDefinition<{
+    url: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: true;
+        comments: string;
+        example: string;
+        clean: (value: unknown) => string;
+    };
+    method: {
+        label: string;
+        type: "string";
+        required: true;
+        model: {
+            label: import("axios").Method;
+            value: import("axios").Method;
+        }[];
+        comments: string;
+        clean: (value: unknown) => string;
+    };
+    data: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: false;
+        comments: string;
+        example: string;
+        clean: (value: unknown) => string;
+    };
+    formData: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+        example: string;
+    };
+    fileData: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+        example: string;
+    };
+    queryParams: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+    };
+    headers: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+        example: string;
+    };
+    responseType: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        default: string;
+        required: true;
+        comments: string;
+        model: {
+            label: import("axios").ResponseType;
+            value: import("axios").ResponseType;
+        }[];
+        clean: (value: unknown) => import("axios").ResponseType;
+    };
+    timeout: {
+        label: string;
+        type: "string";
+        required: false;
+        comments: string;
+        example: string;
+        clean: (value: unknown) => number;
+    };
+    debugRequest: {
+        label: string;
+        type: "boolean";
+        required: false;
+        comments: string;
+        clean: (value: unknown) => boolean;
+    };
+    retryDelayMS: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: false;
+        comments: string;
+        default: string;
+        clean: (value: unknown) => number;
+    };
+    retryAllErrors: {
+        label: string;
+        type: "boolean";
+        default: string;
+        required: false;
+        comments: string;
+        clean: (value: unknown) => boolean;
+    };
+    maxRetries: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: false;
+        comments: string;
+        default: string;
+        clean: (value: unknown) => number;
+    };
+    useExponentialBackoff: {
+        label: string;
+        type: "boolean";
+        default: string;
+        required: false;
+        comments: string;
+        clean: (value: unknown) => boolean;
+    };
+    connection: {
+        label: string;
+        type: "connection";
+        required: true;
+    };
+}, boolean, {
+    data: any;
+}>;
+export { inputs };

package/dist/clients/http/index.js

@@ -1,12 +1,94 @@
 "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;
+};
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleErrors = exports.createClient = void 0;
+exports.inputs = exports.buildRawRequestAction = exports.sendRawRequest = exports.handleErrors = exports.createClient = void 0;
+const lodash_1 = require("lodash");
 const axios_1 = __importDefault(require("axios"));
-const axios_retry_1 = __importDefault(require("axios-retry"));
-const util_1 = require("../../util");
+const axios_retry_1 = __importStar(require("axios-retry"));
+const form_data_1 = __importDefault(require("form-data"));
+const __1 = require("../..");
+const util_1 = __importDefault(require("../../util"));
+const inputs_1 = require("./inputs");
+Object.defineProperty(exports, "inputs", { enumerable: true, get: function () { return inputs_1.inputs; } });
+const toAuthorizationHeaders = (connection) => {
+    var _a, _b, _c, _d;
+    const accessToken = util_1.default.types.toString((_a = connection.token) === null || _a === void 0 ? void 0 : _a.access_token);
+    if (accessToken) {
+        return { Authorization: `Bearer ${accessToken}` };
+    }
+    const apiKey = util_1.default.types.toString((_b = connection.fields) === null || _b === void 0 ? void 0 : _b.apiKey);
+    if (apiKey) {
+        return { Authorization: `Bearer ${apiKey}` };
+    }
+    const username = util_1.default.types.toString((_c = connection.fields) === null || _c === void 0 ? void 0 : _c.username);
+    const password = util_1.default.types.toString((_d = connection.fields) === null || _d === void 0 ? void 0 : _d.password);
+    if (username && password) {
+        const encoded = Buffer.from(`${username}:${password}`).toString("base64");
+        return { Authorization: `Basic ${encoded}` };
+    }
+    throw new Error(`Failed to guess at authorization parameters for Connection: ${connection.key}`);
+};
+const toFormData = (formData, fileData) => {
+    const form = new form_data_1.default();
+    (formData || []).map(({ key, value }) => form.append(key, value));
+    (fileData || []).map(({ key, value }) => form.append(key, value, { filename: key }));
+    return form;
+};
+const computeRetryDelay = (retryDelay, useExponentialBackoff) => {
+    if (useExponentialBackoff) {
+        return axios_retry_1.exponentialDelay;
+    }
+    return typeof retryDelay === "number" ? () => retryDelay : retryDelay;
+};
+const toAxiosRetryConfig = (_a) => {
+    var { retryDelay, retryAllErrors, retryCondition, useExponentialBackoff } = _a, rest = __rest(_a, ["retryDelay", "retryAllErrors", "retryCondition", "useExponentialBackoff"]);
+    return (Object.assign(Object.assign({}, rest), { retryDelay: computeRetryDelay(retryDelay, useExponentialBackoff), retryCondition: retryAllErrors ? () => true : retryCondition }));
+};
 const createClient = ({ baseUrl, responseType, headers, timeout, debug = false, retryConfig, }) => {
     const client = axios_1.default.create({
         baseURL: baseUrl,
@@ -18,17 +100,17 @@ const createClient = ({ baseUrl, responseType, headers, timeout, debug = false,
     });
     if (debug) {
         client.interceptors.request.use((request) => {
-            console.log((0, util_1.toJSON)(request));
+            console.log(util_1.default.types.toJSON(request));
             return request;
         });
         client.interceptors.response.use((response) => {
-            console.log((0, util_1.toJSON)(response));
+            console.log(util_1.default.types.toJSON(response));
             return response;
         });
     }
     if (retryConfig) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (0, axios_retry_1.default)(client, retryConfig);
+        (0, axios_retry_1.default)(client, toAxiosRetryConfig(retryConfig));
     }
     return client;
 };
@@ -44,3 +126,39 @@ const handleErrors = (error) => {
     return error;
 };
 exports.handleErrors = handleErrors;
+const sendRawRequest = (baseUrl, values, authorizationHeaders = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    if (values.data && (!(0, lodash_1.isEmpty)(values.formData) || !(0, lodash_1.isEmpty)(values.fileData))) {
+        throw new Error("Cannot specify both Data and File/Form Data.");
+    }
+    const payload = values.data || toFormData(values.formData, values.fileData);
+    const client = (0, exports.createClient)({
+        baseUrl,
+        debug: values.debugRequest,
+        responseType: values.responseType,
+        timeout: values.timeout,
+        retryConfig: {
+            retries: values.maxRetries,
+            retryDelay: values.retryDelayMS,
+            retryAllErrors: values.retryAllErrors,
+            useExponentialBackoff: values.useExponentialBackoff,
+        },
+    });
+    return yield client.request({
+        method: values.method,
+        url: values.url,
+        headers: Object.assign(Object.assign(Object.assign({}, util_1.default.types.keyValPairListToObject(values.headers)), (payload instanceof form_data_1.default ? payload.getHeaders() : {})), authorizationHeaders),
+        params: util_1.default.types.keyValPairListToObject(values.queryParams),
+        data: payload,
+    });
+});
+exports.sendRawRequest = sendRawRequest;
+const buildRawRequestAction = (baseUrl, label = "Raw Request", description = "Issue a raw HTTP request") => (0, __1.action)({
+    display: { label, description },
+    inputs: Object.assign({ connection: { label: "Connection", type: "connection", required: true } }, inputs_1.inputs),
+    perform: (context, _a) => __awaiter(void 0, void 0, void 0, function* () {
+        var { connection } = _a, httpInputValues = __rest(_a, ["connection"]);
+        const { data } = yield (0, exports.sendRawRequest)(baseUrl, httpInputValues, toAuthorizationHeaders(connection));
+        return { data };
+    }),
+});
+exports.buildRawRequestAction = buildRawRequestAction;

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

@@ -28,6 +28,7 @@ export declare const timeout: {
 export declare const method: {
     label: string;
     type: "string";
+    required: true;
     model: {
         label: Method;
         value: Method;
@@ -40,13 +41,13 @@ export declare const responseType: {
     placeholder: string;
     type: "string";
     default: string;
-    required: false;
+    required: true;
     comments: string;
     model: {
         label: ResponseType;
         value: ResponseType;
     }[];
-    clean: (value: unknown) => string;
+    clean: (value: unknown) => ResponseType;
 };
 export declare const headers: {
     label: string;
@@ -81,6 +82,7 @@ export declare const retryDelayMS: {
     required: false;
     comments: string;
     default: string;
+    clean: (value: unknown) => number;
 };
 export declare const useExponentialBackoff: {
     label: string;
@@ -90,7 +92,7 @@ export declare const useExponentialBackoff: {
     comments: string;
     clean: (value: unknown) => boolean;
 };
-export declare const retryOnAllErrors: {
+export declare const retryAllErrors: {
     label: string;
     type: "boolean";
     default: string;
@@ -123,3 +125,131 @@ export declare const debugRequest: {
     comments: string;
     clean: (value: unknown) => boolean;
 };
+export declare const inputs: {
+    url: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: true;
+        comments: string;
+        example: string;
+        clean: (value: unknown) => string;
+    };
+    method: {
+        label: string;
+        type: "string";
+        required: true;
+        model: {
+            label: Method;
+            value: Method;
+        }[];
+        comments: string;
+        clean: (value: unknown) => string;
+    };
+    data: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: false;
+        comments: string;
+        example: string;
+        clean: (value: unknown) => string;
+    };
+    formData: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+        example: string;
+    };
+    fileData: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+        example: string;
+    };
+    queryParams: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+    };
+    headers: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        collection: "keyvaluelist";
+        required: false;
+        comments: string;
+        example: string;
+    };
+    responseType: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        default: string;
+        required: true;
+        comments: string;
+        model: {
+            label: ResponseType;
+            value: ResponseType;
+        }[];
+        clean: (value: unknown) => ResponseType;
+    };
+    timeout: {
+        label: string;
+        type: "string";
+        required: false;
+        comments: string;
+        example: string;
+        clean: (value: unknown) => number;
+    };
+    debugRequest: {
+        label: string;
+        type: "boolean";
+        required: false;
+        comments: string;
+        clean: (value: unknown) => boolean;
+    };
+    retryDelayMS: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: false;
+        comments: string;
+        default: string;
+        clean: (value: unknown) => number;
+    };
+    retryAllErrors: {
+        label: string;
+        type: "boolean";
+        default: string;
+        required: false;
+        comments: string;
+        clean: (value: unknown) => boolean;
+    };
+    maxRetries: {
+        label: string;
+        placeholder: string;
+        type: "string";
+        required: false;
+        comments: string;
+        default: string;
+        clean: (value: unknown) => number;
+    };
+    useExponentialBackoff: {
+        label: string;
+        type: "boolean";
+        default: string;
+        required: false;
+        comments: string;
+        clean: (value: unknown) => boolean;
+    };
+};

package/dist/clients/http/inputs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugRequest = exports.fileData = exports.formData = exports.retryOnAllErrors = exports.useExponentialBackoff = exports.retryDelayMS = exports.maxRetries = exports.queryParams = exports.headers = exports.responseType = exports.method = exports.timeout = exports.data = exports.url = void 0;
+exports.inputs = exports.debugRequest = exports.fileData = exports.formData = exports.retryAllErrors = exports.useExponentialBackoff = exports.retryDelayMS = exports.maxRetries = exports.queryParams = exports.headers = exports.responseType = exports.method = exports.timeout = exports.data = exports.url = void 0;
 const __1 = require("../..");
 const supportedMethods = [
     "DELETE",
@@ -49,6 +49,7 @@ exports.timeout = (0, __1.input)({
 exports.method = (0, __1.input)({
     label: "Method",
     type: "string",
+    required: true,
     model: supportedMethods.map((method) => ({ label: method, value: method })),
     comments: "The HTTP method to use.",
     clean: (value) => __1.util.types.toString(value),
@@ -58,7 +59,7 @@ exports.responseType = (0, __1.input)({
     placeholder: "Response Type",
     type: "string",
     default: "json",
-    required: false,
+    required: true,
     comments: "The type of data you expect in the response. You can request json, text, or binary data.",
     model: supportedResponseTypes.map((responseType) => ({
         label: responseType,
@@ -99,6 +100,7 @@ exports.retryDelayMS = (0, __1.input)({
     required: false,
     comments: "The delay in milliseconds between retries.",
     default: "0",
+    clean: (value) => __1.util.types.toNumber(value, 0),
 });
 exports.useExponentialBackoff = (0, __1.input)({
     label: "Use Exponential Backoff",
@@ -108,7 +110,7 @@ exports.useExponentialBackoff = (0, __1.input)({
     comments: "Specifies whether to use a pre-defined exponential backoff strategy for retries.",
     clean: (value) => __1.util.types.toBool(value),
 });
-exports.retryOnAllErrors = (0, __1.input)({
+exports.retryAllErrors = (0, __1.input)({
     label: "Retry On All Errors",
     type: "boolean",
     default: "false",
@@ -141,3 +143,19 @@ exports.debugRequest = (0, __1.input)({
     comments: "Enabling this flag will log out the current request.",
     clean: (value) => __1.util.types.toBool(value),
 });
+exports.inputs = {
+    url: exports.url,
+    method: exports.method,
+    data: exports.data,
+    formData: exports.formData,
+    fileData: exports.fileData,
+    queryParams: exports.queryParams,
+    headers: exports.headers,
+    responseType: exports.responseType,
+    timeout: exports.timeout,
+    debugRequest: exports.debugRequest,
+    retryDelayMS: exports.retryDelayMS,
+    retryAllErrors: exports.retryAllErrors,
+    maxRetries: exports.maxRetries,
+    useExponentialBackoff: exports.useExponentialBackoff,
+};

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  * authors create inputs, actions, and components that can
  * be processed by the Prismatic API.
  */
-import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition } from "./types";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult } from "./types";
 import { convertComponent } from "./serverTypes/convert";
 /**
  * This function creates a component object that can be
@@ -23,7 +23,7 @@ export declare const component: <T extends boolean>(definition: ComponentDefinit
  * @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: <T extends Inputs>(definition: ActionDefinition<T>) => ActionDefinition<T>;
+export declare const action: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, 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 +33,7 @@ export declare const action: <T extends Inputs>(definition: ActionDefinition<T>)
  * @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: <T extends Inputs>(definition: TriggerDefinition<T>) => TriggerDefinition<T>;
+export declare const trigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>>(definition: TriggerDefinition<TInputs, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TAllowsBranching, TResult>;
 /**
  * For information and examples on how to write inputs
  * for custom component actions and triggers, see

package/dist/serverTypes/index.d.ts

@@ -87,6 +87,8 @@ interface TriggerBaseResult {
     instanceState?: Record<string, unknown>;
     crossFlowState?: Record<string, unknown>;
     executionState?: Record<string, unknown>;
+    failed?: boolean;
+    error?: Record<string, unknown>;
 }
 interface TriggerBranchingResult extends TriggerBaseResult {
     branch: string;
@@ -141,6 +143,8 @@ interface ServerPerformDataStructureReturn {
     instanceState?: Record<string, unknown>;
     crossFlowState?: Record<string, unknown>;
     executionState?: Record<string, unknown>;
+    failed?: boolean;
+    error?: Record<string, unknown>;
 }
 interface ServerPerformDataReturn {
     data: Buffer | string | unknown;
@@ -149,6 +153,8 @@ interface ServerPerformDataReturn {
     instanceState?: Record<string, unknown>;
     crossFlowState?: Record<string, unknown>;
     executionState?: Record<string, unknown>;
+    failed?: boolean;
+    error?: Record<string, unknown>;
 }
 interface ServerPerformBranchingDataStructureReturn extends ServerPerformDataStructureReturn {
     branch: string;

package/dist/serverTypes/perform.js

@@ -8,10 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.createPerform = void 0;
 const serialize_error_1 = require("serialize-error");
-const util_1 = require("../util");
+const util_1 = __importDefault(require("../util"));
 const cleanParams = (params, cleaners) => Object.entries(params).reduce((result, [key, value]) => {
     const cleanFn = cleaners[key];
     return Object.assign(Object.assign({}, result), { [key]: cleanFn ? cleanFn(value) : value });
@@ -31,7 +34,7 @@ const createPerform = (performFn, { inputCleaners, errorHandler }) => {
                 throw error;
             }
             const handled = errorHandler(error);
-            const serialized = (0, util_1.toJSON)((0, serialize_error_1.serializeError)(handled));
+            const serialized = util_1.default.types.toJSON((0, serialize_error_1.serializeError)(handled));
             throw new Error(serialized);
         }
     });

package/dist/testing.d.ts

@@ -4,9 +4,9 @@
  * information on unit testing, check out our docs:
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
-import { TriggerPayload, TriggerResult, Connection, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn } from "./serverTypes";
-import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters } from "./types";
-export declare const createConnection: <T extends Connection>({ key }: T, values: Record<string, unknown>) => ConnectionValue;
+import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn } from "./serverTypes";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult } from "./types";
+export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>) => ConnectionValue;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
  * 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.
@@ -25,7 +25,7 @@ interface InvokeReturn<ReturnData> {
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * action result and a mock logger for asserting logging.
  */
-export declare const invoke: <T extends Inputs>({ perform }: ActionDefinition<T>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<import("./types").ActionPerformReturn<boolean | undefined, unknown>>>;
+export declare const invoke: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform }: ActionDefinition<TInputs, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
 export declare const defaultTriggerPayload: () => TriggerPayload;
 /**
  * Invokes specified TriggerDefinition perform function using supplied params
@@ -33,7 +33,7 @@ export declare const defaultTriggerPayload: () => TriggerPayload;
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * trigger result and a mock logger for asserting logging.
  */
-export declare const invokeTrigger: <T extends Inputs>({ perform }: TriggerDefinition<T>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T> | undefined) => Promise<InvokeReturn<import("./types").TriggerResult<boolean | undefined>>>;
+export declare const invokeTrigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching>>({ perform }: TriggerDefinition<TInputs, TAllowsBranching, TResult>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs> | undefined) => Promise<InvokeReturn<TResult>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
@@ -44,8 +44,8 @@ export declare class ComponentTestHarness<TComponent extends Component> {
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
     loggerMock: () => ActionLogger;
-    invoke: <T extends Inputs>({ perform }: ActionDefinition<T>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<import("./types").ActionPerformReturn<boolean | undefined, unknown>>>;
-    invokeTrigger: <T_1 extends Inputs>({ perform }: TriggerDefinition<T_1>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T_1> | undefined) => Promise<InvokeReturn<import("./types").TriggerResult<boolean | undefined>>>;
+    invoke: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform }: ActionDefinition<TInputs, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
+    invokeTrigger: <TInputs_1 extends Inputs, TAllowsBranching_1 extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching_1>>({ perform }: TriggerDefinition<TInputs_1, TAllowsBranching_1, TResult>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs_1> | undefined) => Promise<InvokeReturn<TResult>>;
     createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 };
 export default _default;

package/dist/types/ActionDefinition.d.ts

@@ -1,13 +1,13 @@
-import { ActionDisplayDefinition, ActionPerformFunction, Inputs } from ".";
+import { ActionDisplayDefinition, ActionPerformFunction, ActionPerformReturn, Inputs } from ".";
 /**
  * ActionDefinition is the type of the object that is passed in to `action` function to
  * define a component action.
  */
-export interface ActionDefinition<TInputs extends Inputs> {
+export interface ActionDefinition<TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> {
     /** Defines how the Action is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Action is invoked. */
-    perform: ActionPerformFunction<this["inputs"], this["allowsBranching"]>;
+    perform: ActionPerformFunction<TInputs, TAllowsBranching, TReturn>;
     /** InputFields to present in the Prismatic interface for configuration of this Action. */
     inputs: TInputs;
     /** Optional attribute that specifies whether an Action will terminate execution.*/
@@ -15,7 +15,7 @@ export interface ActionDefinition<TInputs extends Inputs> {
     /** Specifies whether an Action will break out of a loop. */
     breakLoop?: boolean;
     /** Determines whether an Action will allow Conditional Branching.*/
-    allowsBranching?: boolean;
+    allowsBranching?: TAllowsBranching;
     /** Static Branch names associated with an Action. */
     staticBranchNames?: string[];
     /** The Input associated with Dynamic Branching.*/

package/dist/types/ActionPerformFunction.d.ts

@@ -1,6 +1,6 @@
 import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger } from ".";
 /** Definition of the function to perform when an Action is invoked. */
-export declare type ActionPerformFunction<TInputs extends Inputs, AllowsBranching extends boolean | undefined> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<ActionPerformReturn<AllowsBranching, unknown>>;
+export declare type ActionPerformFunction<TInputs extends Inputs, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
 /** Context provided to perform method containing helpers and contextual data */
 export interface ActionContext {
     /** Logger for permanent logging; console calls are also captured */

package/dist/types/ActionPerformReturn.d.ts

@@ -12,6 +12,10 @@ export interface ActionPerformDataReturn<ReturnData> {
     crossFlowState?: 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>;
+    /** A field populated by the Prismatic platform which indicates whether the trigger failed with an error during execution. */
+    failed?: boolean;
+    /** A field populated by the Prismatic platform which may refer to an object that contains data about any error that resulted in failure. */
+    error?: 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/ComponentDefinition.d.ts

@@ -13,9 +13,9 @@ export declare type ComponentDefinition<TPublic extends boolean> = {
     /** Defines how the Component is displayed in the Prismatic interface. */
     display: ComponentDisplayDefinition<TPublic>;
     /** Specifies the supported Actions of this Component. */
-    actions?: Record<string, ActionDefinition<any>>;
+    actions?: Record<string, ActionDefinition<any, boolean, any>>;
     /** Specifies the supported Triggers of this Component. */
-    triggers?: Record<string, TriggerDefinition<any>>;
+    triggers?: Record<string, TriggerDefinition<any, boolean, any>>;
     /** Specifies the supported Connections of this Component. */
     connections?: ConnectionDefinition[];
     /** Hooks */

package/dist/types/TriggerDefinition.d.ts

@@ -1,4 +1,4 @@
-import { ActionDisplayDefinition, TriggerPerformFunction, Inputs } from ".";
+import { ActionDisplayDefinition, TriggerPerformFunction, Inputs, TriggerResult } from ".";
 declare const optionChoices: readonly ["invalid", "valid", "required"];
 export declare type TriggerOptionChoice = typeof optionChoices[number];
 export declare const TriggerOptionChoices: TriggerOptionChoice[];
@@ -6,11 +6,11 @@ export declare const TriggerOptionChoices: TriggerOptionChoice[];
  * TriggerDefinition is the type of the object that is passed in to `trigger` function to
  * define a component trigger.
  */
-export interface TriggerDefinition<TInputs extends Inputs> {
+export interface TriggerDefinition<TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>> {
     /** Defines how the Trigger is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Trigger is invoked. */
-    perform: TriggerPerformFunction<this["inputs"], this["allowsBranching"]>;
+    perform: TriggerPerformFunction<TInputs, TAllowsBranching, TResult>;
     /** InputFields to present in the Prismatic interface for configuration of this Trigger. */
     inputs: TInputs;
     /** Specifies whether this Trigger supports executing the Integration on a recurring schedule. */
@@ -22,7 +22,7 @@ export interface TriggerDefinition<TInputs extends Inputs> {
     /** Specifies whether an Action will break out of a loop. */
     breakLoop?: boolean;
     /** Determines whether this Trigger allows Conditional Branching. */
-    allowsBranching?: boolean;
+    allowsBranching?: TAllowsBranching;
     /** Static Branch names associated with this Trigger. */
     staticBranchNames?: string[];
     /** The Input associated with Dynamic Branching. */

package/dist/types/TriggerPerformFunction.d.ts

@@ -1,3 +1,3 @@
 import { Inputs, TriggerResult, ActionInputParameters, ActionContext, TriggerPayload } from ".";
 /** Definition of the function to perform when a Trigger is invoked. */
-export declare type TriggerPerformFunction<T extends Inputs, AllowsBranching extends boolean | undefined> = (context: ActionContext, payload: TriggerPayload, params: ActionInputParameters<T>) => Promise<TriggerResult<AllowsBranching>>;
+export declare type TriggerPerformFunction<T extends Inputs, TAllowsBranching extends boolean | undefined, TResult extends TriggerResult<TAllowsBranching>> = (context: ActionContext, payload: TriggerPayload, params: ActionInputParameters<T>) => Promise<TResult>;

package/dist/types/TriggerResult.d.ts

@@ -12,6 +12,10 @@ export interface TriggerBaseResult {
     crossFlowState?: 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>;
+    /** A field populated by the Prismatic platform which indicates whether the trigger failed with an error during execution. */
+    failed?: boolean;
+    /** A field populated by the Prismatic platform which may refer to an object that contains data about any error that resulted in failure. */
+    error?: Record<string, unknown>;
 }
 /** Represents the result of a Trigger action that uses branching. */
 export interface TriggerBranchingResult extends TriggerBaseResult {

package/dist/util.d.ts

@@ -4,12 +4,6 @@
  * For example, `util.types.toInt("5.5")` will return an integer, `5`.
  */
 import { KeyValuePair, DataPayload } from "./types";
-/** This function accepts an arbitrary object/value and safely serializes it (handles cyclic references).
- *
- * @param value Arbitrary object/value to serialize.
- * @returns JSON serialized text that can be safely logged.
- */
-export declare const toJSON: (value: unknown) => string;
 /**
  * This function returns a lower cased version of the headers passed to it.
  *
@@ -38,7 +32,7 @@ declare const _default: {
         isData: (value: unknown) => boolean;
         toData: (value: unknown) => DataPayload;
         toString: (value: unknown, defaultValue?: string) => string;
-        keyValPairListToObject: <TValue = unknown>(kvpList?: KeyValuePair<unknown>[], valueConverter?: ((value: unknown) => TValue) | undefined) => Record<string, TValue>;
+        keyValPairListToObject: <TValue = unknown>(kvpList: KeyValuePair<unknown>[], valueConverter?: ((value: unknown) => TValue) | undefined) => Record<string, TValue>;
         isJSON: (value: string) => boolean;
         toJSON: (value: unknown) => string;
         lowerCaseHeaders: (headers: Record<string, string>) => Record<string, string>;

package/dist/util.js

@@ -8,7 +8,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lowerCaseHeaders = exports.toJSON = void 0;
+exports.lowerCaseHeaders = void 0;
 /** */
 const parseISO_1 = __importDefault(require("date-fns/parseISO"));
 const isValid_1 = __importDefault(require("date-fns/isValid"));
@@ -197,8 +197,8 @@ const isUrl = (value) => (0, valid_url_1.isWebUri)(value) !== undefined;
  * @param kvpList An array of objects with `key` and `value` properties.
  * @param valueConverter Optional function to call for each `value`.
  */
-const keyValPairListToObject = (kvpList = [], valueConverter) => {
-    return kvpList.reduce((result, { key, value }) => (Object.assign(Object.assign({}, result), { [key]: valueConverter ? valueConverter(value) : value })), {});
+const keyValPairListToObject = (kvpList, valueConverter) => {
+    return (kvpList || []).reduce((result, { key, value }) => (Object.assign(Object.assign({}, result), { [key]: valueConverter ? valueConverter(value) : value })), {});
 };
 /**
  * This function tests if the object provided is a Prismatic `DataPayload` object.
@@ -322,7 +322,6 @@ const toJSON = (value) => {
     const stringify = (0, safe_stable_stringify_1.configure)({ circularValue: undefined });
     return stringify(value, null, 2);
 };
-exports.toJSON = toJSON;
 /**
  * This function returns a lower cased version of the headers passed to it.
  *
@@ -356,7 +355,7 @@ exports.default = {
         toString,
         keyValPairListToObject,
         isJSON,
-        toJSON: exports.toJSON,
+        toJSON,
         lowerCaseHeaders: exports.lowerCaseHeaders,
     },
     docs: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "6.4.0",
+  "version": "6.5.1",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"
@@ -37,9 +37,10 @@
     "dist/"
   ],
   "dependencies": {
-    "axios": "0.26.1",
-    "axios-retry": "3.2.4",
+    "axios": "0.27.2",
+    "axios-retry": "3.2.5",
     "date-fns": "2.28.0",
+    "form-data": "4.0.0",
     "jest-mock": "27.0.3",
     "soap": "0.43.0",
     "uuid": "8.3.2",