@prismatic-io/spectral 6.2.0 → 6.4.1

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

@@ -6,6 +6,7 @@ export declare const url: {
     required: true;
     comments: string;
     example: string;
+    clean: (value: unknown) => string;
 };
 export declare const data: {
     label: string;
@@ -14,6 +15,7 @@ export declare const data: {
     required: false;
     comments: string;
     example: string;
+    clean: (value: unknown) => string;
 };
 export declare const timeout: {
     label: string;
@@ -21,6 +23,7 @@ export declare const timeout: {
     required: false;
     comments: string;
     example: string;
+    clean: (value: unknown) => number;
 };
 export declare const method: {
     label: string;
@@ -30,6 +33,7 @@ export declare const method: {
         value: Method;
     }[];
     comments: string;
+    clean: (value: unknown) => string;
 };
 export declare const responseType: {
     label: string;
@@ -42,6 +46,7 @@ export declare const responseType: {
         label: ResponseType;
         value: ResponseType;
     }[];
+    clean: (value: unknown) => string;
 };
 export declare const headers: {
     label: string;
@@ -67,6 +72,7 @@ export declare const maxRetries: {
     required: false;
     comments: string;
     default: string;
+    clean: (value: unknown) => number;
 };
 export declare const retryDelayMS: {
     label: string;
@@ -82,6 +88,7 @@ export declare const useExponentialBackoff: {
     default: string;
     required: false;
     comments: string;
+    clean: (value: unknown) => boolean;
 };
 export declare const retryOnAllErrors: {
     label: string;
@@ -89,6 +96,7 @@ export declare const retryOnAllErrors: {
     default: string;
     required: false;
     comments: string;
+    clean: (value: unknown) => boolean;
 };
 export declare const formData: {
     label: string;
@@ -113,4 +121,5 @@ export declare const debugRequest: {
     type: "boolean";
     required: false;
     comments: string;
+    clean: (value: unknown) => boolean;
 };

package/dist/clients/http/inputs.js

@@ -27,6 +27,7 @@ exports.url = (0, __1.input)({
     required: true,
     comments: "This is the URL to call.",
     example: "/sobjects/Account",
+    clean: (value) => __1.util.types.toString(value),
 });
 exports.data = (0, __1.input)({
     label: "Data",
@@ -35,6 +36,7 @@ exports.data = (0, __1.input)({
     required: false,
     comments: "The HTTP body payload to send to the URL. Must be a string or a reference to output from a previous step.",
     example: '{"exampleKey": "Example Data"}',
+    clean: (value) => __1.util.types.toString(value),
 });
 exports.timeout = (0, __1.input)({
     label: "Timeout",
@@ -42,12 +44,14 @@ exports.timeout = (0, __1.input)({
     required: false,
     comments: "The maximum time that a client will await a response to its request",
     example: "2000",
+    clean: (value) => __1.util.types.toNumber(value),
 });
 exports.method = (0, __1.input)({
     label: "Method",
     type: "string",
     model: supportedMethods.map((method) => ({ label: method, value: method })),
     comments: "The HTTP method to use.",
+    clean: (value) => __1.util.types.toString(value),
 });
 exports.responseType = (0, __1.input)({
     label: "Response Type",
@@ -60,6 +64,7 @@ exports.responseType = (0, __1.input)({
         label: responseType,
         value: responseType,
     })),
+    clean: (value) => __1.util.types.toString(value),
 });
 exports.headers = (0, __1.input)({
     label: "Header",
@@ -85,6 +90,7 @@ exports.maxRetries = (0, __1.input)({
     required: false,
     comments: "The maximum number of retries to attempt.",
     default: "0",
+    clean: (value) => __1.util.types.toNumber(value),
 });
 exports.retryDelayMS = (0, __1.input)({
     label: "Retry Delay (ms)",
@@ -100,6 +106,7 @@ exports.useExponentialBackoff = (0, __1.input)({
     default: "false",
     required: false,
     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)({
     label: "Retry On All Errors",
@@ -107,6 +114,7 @@ exports.retryOnAllErrors = (0, __1.input)({
     default: "false",
     required: false,
     comments: "If true, retries on all erroneous responses regardless of type.",
+    clean: (value) => __1.util.types.toBool(value),
 });
 exports.formData = (0, __1.input)({
     label: "Form Data",
@@ -131,4 +139,5 @@ exports.debugRequest = (0, __1.input)({
     type: "boolean",
     required: false,
     comments: "Enabling this flag will log out the current request.",
+    clean: (value) => __1.util.types.toBool(value),
 });

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/convert.js

@@ -1,13 +1,4 @@
 "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 __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)
@@ -21,40 +12,42 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertComponent = void 0;
-const serialize_error_1 = require("serialize-error");
-const util_1 = require("../util");
 const types_1 = require("../types");
-const wrapPerform = (fn, errorHandler) => {
-    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            return yield fn(...args);
-        }
-        catch (error) {
-            throw new Error((0, util_1.toJSON)((0, serialize_error_1.serializeError)(errorHandler(error))));
-        }
-    });
-};
+const perform_1 = require("./perform");
 const convertInput = (key, _a) => {
     var { default: defaultValue, type, label, collection } = _a, rest = __rest(_a, ["default", "type", "label", "collection"]);
-    return (Object.assign(Object.assign({}, rest), { key,
-        type, default: defaultValue !== null && defaultValue !== void 0 ? defaultValue : types_1.InputFieldDefaultMap[type], collection, label: typeof label === "string" ? label : label.value, keyLabel: collection === "keyvaluelist" && typeof label === "object"
-            ? label.key
-            : undefined }));
+    const keyLabel = collection === "keyvaluelist" && typeof label === "object"
+        ? label.key
+        : undefined;
+    return Object.assign(Object.assign({}, rest), { key,
+        type, default: defaultValue !== null && defaultValue !== void 0 ? defaultValue : types_1.InputFieldDefaultMap[type], collection, label: typeof label === "string" ? label : label.value, keyLabel });
 };
 const convertAction = (actionKey, _a, hooks) => {
     var { inputs = {}, perform } = _a, action = __rest(_a, ["inputs", "perform"]);
-    return (Object.assign(Object.assign({}, action), { key: actionKey, perform: (hooks === null || hooks === void 0 ? void 0 : hooks.error) ? wrapPerform(perform, hooks.error) : perform, inputs: Object.entries(inputs).map(([key, value]) => convertInput(key, value)) }));
+    const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
+    const inputCleaners = Object.entries(inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
+    return Object.assign(Object.assign({}, action), { key: actionKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
+            inputCleaners,
+            errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
+        }) });
 };
 const convertTrigger = (triggerKey, _a, hooks) => {
     var { inputs = {}, perform } = _a, trigger = __rest(_a, ["inputs", "perform"]);
-    return (Object.assign(Object.assign({}, trigger), { key: triggerKey, perform: (hooks === null || hooks === void 0 ? void 0 : hooks.error) ? wrapPerform(perform, hooks.error) : perform, inputs: Object.entries(inputs).map(([key, value]) => convertInput(key, value)) }));
+    const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
+    return Object.assign(Object.assign({}, trigger), { key: triggerKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
+            inputCleaners: {},
+            errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
+        }) });
 };
-const convertConnection = (connection) => {
-    var _a;
-    return (Object.assign(Object.assign({}, connection), { inputs: Object.entries((_a = connection.inputs) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => convertInput(key, value)) }));
+const convertConnection = (_a) => {
+    var { inputs = {} } = _a, connection = __rest(_a, ["inputs"]);
+    const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
+    return Object.assign(Object.assign({}, connection), { inputs: convertedInputs });
 };
 const convertComponent = (_a) => {
     var { connections = [], actions = {}, triggers = {}, hooks } = _a, definition = __rest(_a, ["connections", "actions", "triggers", "hooks"]);
-    return (Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: Object.entries(actions).reduce((result, [actionKey, action]) => (Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, action, hooks) })), {}), triggers: Object.entries(triggers).reduce((result, [triggerKey, trigger]) => (Object.assign(Object.assign({}, result), { [triggerKey]: convertTrigger(triggerKey, trigger, hooks) })), {}) }));
+    const convertedActions = Object.entries(actions).reduce((result, [actionKey, action]) => (Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, action, hooks) })), {});
+    const convertedTriggers = Object.entries(triggers).reduce((result, [triggerKey, trigger]) => (Object.assign(Object.assign({}, result), { [triggerKey]: convertTrigger(triggerKey, trigger, hooks) })), {});
+    return Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: convertedActions, triggers: convertedTriggers });
 };
 exports.convertComponent = convertComponent;

package/dist/serverTypes/index.d.ts

@@ -60,6 +60,7 @@ export interface TriggerPayload {
         data: unknown;
         contentType?: string;
     };
+    pathFragment: string;
     webhookUrls: Record<string, string>;
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;

package/dist/serverTypes/perform.d.ts

@@ -0,0 +1,10 @@
+import { ErrorHandler } from "../types";
+declare type PerformFn = (...args: any[]) => Promise<any>;
+export declare type CleanFn = (...args: any[]) => any;
+export declare type InputCleaners = Record<string, CleanFn | undefined>;
+interface CreatePerformProps {
+    inputCleaners: InputCleaners;
+    errorHandler?: ErrorHandler;
+}
+export declare const createPerform: (performFn: PerformFn, { inputCleaners, errorHandler }: CreatePerformProps) => PerformFn;
+export {};

package/dist/serverTypes/perform.js

@@ -0,0 +1,39 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPerform = void 0;
+const serialize_error_1 = require("serialize-error");
+const util_1 = 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 });
+}, {});
+const createPerform = (performFn, { inputCleaners, errorHandler }) => {
+    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (args.length === 2) {
+                const [context, params] = args;
+                return yield performFn(context, cleanParams(params, inputCleaners));
+            }
+            const [context, payload, params] = args;
+            return yield performFn(context, payload, cleanParams(params, inputCleaners));
+        }
+        catch (error) {
+            if (!errorHandler) {
+                throw error;
+            }
+            const handled = errorHandler(error);
+            const serialized = (0, util_1.toJSON)((0, serialize_error_1.serializeError)(handled));
+            throw new Error(serialized);
+        }
+    });
+};
+exports.createPerform = createPerform;

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/testing.js

@@ -68,6 +68,7 @@ const defaultTriggerPayload = () => {
             data: JSON.stringify(payloadData),
             contentType,
         },
+        pathFragment: "",
         webhookUrls: {
             "Flow 1": "https://example.com",
         },

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/ActionInputParameters.d.ts

@@ -1,14 +1,15 @@
-import { InputFieldDefinition, Inputs, InputFieldTypeMap } from ".";
+import { Inputs } from ".";
+import { ConditionalExpression } from "./conditional-logic";
+import { InputFieldCollection, InputCleanFunction, Connection } from "./Inputs";
 /**
  * Collection of input parameters.
  * Inputs can be static values, references to config variables, or
  * references to previous steps' outputs.
  */
 export declare type ActionInputParameters<TInputs extends Inputs> = {
-    [Property in keyof TInputs]: ExtractValue<TInputs[Property]>;
+    [Property in keyof TInputs]: TInputs[Property]["clean"] extends InputCleanFunction<any> ? ReturnType<TInputs[Property]["clean"]> : TInputs[Property]["type"] extends "connection" ? ExtractValue<Connection, TInputs[Property]["collection"]> : TInputs[Property]["type"] extends "conditional" ? ExtractValue<ConditionalExpression, TInputs[Property]["collection"]> : ExtractValue<TInputs[Property]["default"], TInputs[Property]["collection"]>;
 };
-export declare type ExtractValue<TValue extends InputFieldDefinition> = MapCollectionValues<InputFieldTypeMap[TValue["type"]], TValue["collection"]>;
-export declare type MapCollectionValues<TType, TCollection extends InputFieldDefinition["collection"]> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] : TCollection extends "valuelist" ? TType[] : TType;
+export declare type ExtractValue<TType, TCollection extends InputFieldCollection | undefined> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] : TCollection extends "valuelist" ? TType[] : TType;
 /**
  * KeyValuePair input parameter type.
  * This allows users to input multiple keys / values as an input.

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/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/Inputs.d.ts

@@ -1,23 +1,21 @@
-import { InputFieldDefaultMap, InputFieldType } from ".";
+import { ConditionalExpression } from "./conditional-logic";
+/** InputField type enumeration. */
+export declare type InputFieldType = InputFieldDefinition["type"];
+export declare const InputFieldDefaultMap: Record<InputFieldType, string | undefined>;
 export declare type Inputs = Record<string, InputFieldDefinition>;
-export declare type ConnectionInput = DefaultInputFieldDefinition & {
+export declare type ConnectionInput = (StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField) & {
     shown?: boolean;
 };
-export declare type InputFieldDefinition = DefaultInputFieldDefinition | CodeInputFieldDefinition | ConditionalInputField | ConnectionInputField;
-interface BaseInputFieldDefinition {
-    /** Data type the InputField will collect. */
-    type: InputFieldType;
+export declare type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField;
+export declare type InputCleanFunction<TValue, TResult = TValue> = (value: TValue) => TResult;
+interface BaseInputField {
     /** Interface label of the InputField. */
     label: {
         key: string;
         value: string;
     } | string;
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
     /** Text to show as the InputField placeholder. */
     placeholder?: string;
-    /** Default value for this field. */
-    default?: typeof InputFieldDefaultMap[this["type"]];
     /** Additional text to give guidance to the user configuring the InputField. */
     comments?: string;
     /** Example valid input for this InputField. */
@@ -25,27 +23,102 @@ interface BaseInputFieldDefinition {
     /** Indicate if this InputField is required. */
     required?: boolean;
 }
-/** Defines attributes of a InputField. */
-export interface DefaultInputFieldDefinition extends BaseInputFieldDefinition {
-    type: Exclude<InputFieldType, "code" | "conditional" | "connection">;
+export interface StringInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "string";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+export interface DataInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "data";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+export interface TextInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "text";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+export interface PasswordInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "password";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+export interface BooleanInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "boolean";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
 }
 /** Defines attributes of a CodeInputField. */
-export interface CodeInputFieldDefinition extends BaseInputFieldDefinition {
-    type: Extract<InputFieldType, "code">;
+export interface CodeInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "code";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
     /** Code language of this field. */
     language?: string;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
 }
 /** Defines attributes of a ConditionalInputField. */
-export interface ConditionalInputField extends BaseInputFieldDefinition {
-    type: Extract<InputFieldType, "conditional">;
+export interface ConditionalInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "conditional";
+    /** Collection type of the InputField */
+    collection: Extract<InputFieldCollection, "valuelist">;
+    /** Default value for this field. */
+    default?: ConditionalExpression;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
 }
 /** Defines attributes of a ConnectionInputField. */
-export interface ConnectionInputField extends BaseInputFieldDefinition {
-    type: Extract<InputFieldType, "connection">;
+export interface ConnectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "connection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: Connection;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
 }
 export interface Connection {
     /** Key of the Connection type. */

package/dist/types/Inputs.js

@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputFieldDefaultMap = void 0;
+exports.InputFieldDefaultMap = {
+    string: "",
+    data: "",
+    text: "",
+    password: "",
+    boolean: "false",
+    code: "",
+    conditional: undefined,
+    connection: undefined,
+};

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/TriggerPayload.d.ts

@@ -14,6 +14,8 @@ export interface TriggerPayload {
         data: unknown;
         contentType?: string;
     };
+    /** Extended path information from the webhook trigger */
+    pathFragment: string;
     /** The webhook URLs assigned to this integration's flows upon instance deploy */
     webhookUrls: {
         [key: string]: string;

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/index.d.ts

@@ -12,7 +12,6 @@ export * from "./DisplayDefinition";
 export * from "./ActionInputParameters";
 export * from "./ActionLogger";
 export * from "./ActionPerformFunction";
-export * from "./InputFieldType";
 export * from "./conditional-logic";
 export * from "./TriggerResult";
 export * from "./TriggerPerformFunction";

package/dist/types/index.js

@@ -28,7 +28,6 @@ __exportStar(require("./DisplayDefinition"), exports);
 __exportStar(require("./ActionInputParameters"), exports);
 __exportStar(require("./ActionLogger"), exports);
 __exportStar(require("./ActionPerformFunction"), exports);
-__exportStar(require("./InputFieldType"), exports);
 __exportStar(require("./conditional-logic"), exports);
 __exportStar(require("./TriggerResult"), exports);
 __exportStar(require("./TriggerPerformFunction"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "6.2.0",
+  "version": "6.4.1",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"

package/dist/types/InputFieldType.d.ts

@@ -1,15 +0,0 @@
-import { Connection } from ".";
-import { ConditionalExpression } from "./conditional-logic";
-/** InputField type enumeration. */
-export declare type InputFieldType = keyof InputFieldTypeMap;
-export declare type InputFieldTypeMap = {
-    string: unknown;
-    data: unknown;
-    text: unknown;
-    password: unknown;
-    boolean: unknown;
-    code: unknown;
-    conditional: ConditionalExpression;
-    connection: Connection;
-};
-export declare const InputFieldDefaultMap: Record<InputFieldType, string | undefined>;

package/dist/types/InputFieldType.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputFieldDefaultMap = void 0;
-exports.InputFieldDefaultMap = {
-    string: "",
-    data: "",
-    text: "",
-    password: "",
-    boolean: "false",
-    code: "",
-    conditional: undefined,
-    connection: undefined,
-};