@prismatic-io/spectral 6.6.1 → 7.0.0

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, ActionPerformReturn, TriggerResult } from "./types";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition } from "./types";
 import { convertComponent } from "./serverTypes/convert";
 /**
  * This function creates a component object that can be
@@ -34,6 +34,32 @@ export declare const action: <TInputs extends Inputs, TAllowsBranching extends b
  * @returns This function validates the shape of the `definition` object provided, and returns the same trigger object.
  */
 export declare const trigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>>(definition: TriggerDefinition<TInputs, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TAllowsBranching, TResult>;
+/**
+ * This function creates a data source object that can be referenced
+ * by a custom component. It helps ensure that the shape of the
+ * data source object conforms to what the Prismatic API expects.
+ * For information on writing custom component data sources, see
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#writing-data-sources.
+ * @param definition A DataSourceDefinition type object that includes UI display information, a function to perform when the data source 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 data source object.
+ */
+export declare const dataSource: <TInputs extends Inputs, TDataSourceType extends keyof {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string[];
+    schedule: {
+        value: string;
+    };
+    code: string;
+    credential: unknown;
+    boolean: boolean;
+    number: number;
+    connection: import("./types").ConnectionDefinition;
+    objectSelection: import("./types").ObjectSelection;
+    objectFieldMap: import("./types").ObjectFieldMap;
+    jsonForm: import("./types").JSONForm;
+}>(definition: DataSourceDefinition<TInputs, TDataSourceType>) => DataSourceDefinition<TInputs, TDataSourceType>;
 /**
  * For information and examples on how to write inputs
  * for custom component actions and triggers, see

package/dist/index.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.trigger = exports.action = exports.component = void 0;
+exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = void 0;
 const convert_1 = require("./serverTypes/convert");
 /**
  * This function creates a component object that can be
@@ -56,6 +56,17 @@ exports.action = action;
  */
 const trigger = (definition) => definition;
 exports.trigger = trigger;
+/**
+ * This function creates a data source object that can be referenced
+ * by a custom component. It helps ensure that the shape of the
+ * data source object conforms to what the Prismatic API expects.
+ * For information on writing custom component data sources, see
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#writing-data-sources.
+ * @param definition A DataSourceDefinition type object that includes UI display information, a function to perform when the data source 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 data source object.
+ */
+const dataSource = (definition) => definition;
+exports.dataSource = dataSource;
 /**
  * For information and examples on how to write inputs
  * for custom component actions and triggers, see

package/dist/serverTypes/convert.d.ts

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

package/dist/serverTypes/convert.js

@@ -34,8 +34,18 @@ const convertAction = (actionKey, _a, hooks) => {
 const convertTrigger = (triggerKey, _a, hooks) => {
     var { inputs = {}, perform } = _a, trigger = __rest(_a, ["inputs", "perform"]);
     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({}, trigger), { key: triggerKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
-            inputCleaners: {},
+            inputCleaners,
+            errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
+        }) });
+};
+const convertDataSource = (dataSourceKey, _a, hooks) => {
+    var { inputs = {}, perform } = _a, dataSource = __rest(_a, ["inputs", "perform"]);
+    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({}, dataSource), { key: dataSourceKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
+            inputCleaners,
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
         }) });
 };
@@ -45,9 +55,10 @@ const convertConnection = (_a) => {
     return Object.assign(Object.assign({}, connection), { inputs: convertedInputs });
 };
 const convertComponent = (_a) => {
-    var { connections = [], actions = {}, triggers = {}, hooks } = _a, definition = __rest(_a, ["connections", "actions", "triggers", "hooks"]);
+    var { connections = [], actions = {}, triggers = {}, dataSources = {}, hooks } = _a, definition = __rest(_a, ["connections", "actions", "triggers", "dataSources", "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 });
+    const convertedDataSources = Object.entries(dataSources).reduce((result, [dataSourceKey, dataSource]) => (Object.assign(Object.assign({}, result), { [dataSourceKey]: convertDataSource(dataSourceKey, dataSource, hooks) })), {});
+    return Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: convertedActions, triggers: convertedTriggers, dataSources: convertedDataSources });
 };
 exports.convertComponent = convertComponent;

package/dist/serverTypes/index.d.ts

@@ -1,8 +1,11 @@
 /// <reference types="node" />
+import { Instance, Customer, DataSourceType, DataSourceResultType } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
 }
+export { Instance } from "../types";
+export { Customer } from "../types";
 export interface Component {
     key: string;
     public?: boolean;
@@ -13,6 +16,7 @@ export interface Component {
     };
     actions: Record<string, Action>;
     triggers: Record<string, Trigger>;
+    dataSources: Record<string, DataSource>;
     connections: Connection[];
 }
 export interface Action {
@@ -50,15 +54,8 @@ export interface ActionContext {
     webhookUrls: Record<string, string>;
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    customer: Customer;
+    instance: Instance;
 }
 declare type TriggerOptionChoice = "invalid" | "valid" | "required";
 export interface TriggerPayload {
@@ -77,15 +74,8 @@ export interface TriggerPayload {
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
     executionId: string;
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    customer: Customer;
+    instance: Instance;
 }
 interface HttpResponse {
     statusCode: number;
@@ -125,6 +115,30 @@ export interface Trigger {
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
 }
+export interface DataSourceContext {
+    logger: ActionLogger;
+    customer: Customer;
+    instance: Instance;
+}
+export declare type DataSourceResult = {
+    result: DataSourceResultType;
+    supplementalData?: {
+        data: unknown;
+        contentType: string;
+    };
+};
+export declare type DataSourcePerformFunction = (context: DataSourceContext, params: Record<string, unknown>) => Promise<DataSourceResult>;
+export interface DataSource {
+    key: string;
+    display: DisplayDefinition & {
+        directions?: string;
+        important?: boolean;
+    };
+    inputs: Input[];
+    perform: DataSourcePerformFunction;
+    dataSourceType: DataSourceType;
+    examplePayload?: unknown;
+}
 export declare enum OAuth2Type {
     ClientCredentials = "client_credentials",
     AuthorizationCode = "authorization_code"
@@ -194,4 +208,3 @@ export interface Input {
     model?: InputFieldChoice[];
     language?: string;
 }
-export {};

package/dist/serverTypes/perform.js

@@ -22,6 +22,10 @@ const cleanParams = (params, cleaners) => Object.entries(params).reduce((result,
 const createPerform = (performFn, { inputCleaners, errorHandler }) => {
     return (...args) => __awaiter(void 0, void 0, void 0, function* () {
         try {
+            if (args.length === 1) {
+                const [params] = args;
+                return yield performFn(cleanParams(params, inputCleaners));
+            }
             if (args.length === 2) {
                 const [context, params] = args;
                 return yield performFn(context, cleanParams(params, inputCleaners));

package/dist/testing.d.ts

@@ -4,8 +4,8 @@
  * information on unit testing, check out our docs:
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
-import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn } from "./serverTypes";
-import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult } from "./types";
+import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn, DataSourceResult, DataSourceContext } from "./serverTypes";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult } 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.
@@ -13,7 +13,7 @@ export declare const createConnection: <T extends ConnectionDefinition>({ key }:
  */
 export declare const loggerMock: () => ActionLogger;
 /**
- * The type of data returned by an `invoke()` function used for unit testing component actions.
+ * The type of data returned by an `invoke()` function used for unit testing component actions and triggers.
  */
 interface InvokeReturn<ReturnData> {
     result: ReturnData;
@@ -34,12 +34,37 @@ export declare const defaultTriggerPayload: () => TriggerPayload;
  * trigger result and a mock logger for asserting logging.
  */
 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>>;
+/**
+ * Invokes specified DataSourceDefinition perform function using supplied params.
+ * Accepts a generic type matching DataSourceResult as a convenience to avoid extra
+ * casting within test methods. Returns a DataSourceResult.
+ */
+export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType extends keyof {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string[];
+    schedule: {
+        value: string;
+    };
+    code: string;
+    credential: unknown;
+    boolean: boolean;
+    number: number;
+    connection: ConnectionDefinition;
+    objectSelection: import("./types").ObjectSelection;
+    objectFieldMap: import("./types").ObjectFieldMap;
+    jsonForm: import("./types").JSONForm;
+}>({ perform }: DataSourceDefinition<TInputs, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
+    private buildContext;
+    private buildParams;
     connectionValue({ key }: ConnectionDefinition): ConnectionValue;
     trigger(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<TriggerResult>;
     action(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<ActionPerformReturn>;
+    dataSource(key: string, params?: Record<string, unknown>, context?: Partial<DataSourceContext>): Promise<DataSourceResult>;
 }
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
@@ -47,5 +72,22 @@ declare const _default: {
     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>;
+    invokeDataSource: <TInputs_2 extends Inputs, TDataSourceType extends keyof {
+        string: string;
+        date: string;
+        timestamp: string;
+        picklist: string[];
+        schedule: {
+            value: string;
+        };
+        code: string;
+        credential: unknown;
+        boolean: boolean;
+        number: number;
+        connection: ConnectionDefinition;
+        objectSelection: import("./types").ObjectSelection;
+        objectFieldMap: import("./types").ObjectFieldMap;
+        jsonForm: import("./types").JSONForm;
+    }>({ perform }: DataSourceDefinition<TInputs_2, TDataSourceType>, params: ActionInputParameters<TInputs_2>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 };
 export default _default;

package/dist/testing.js

@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHarness = exports.ComponentTestHarness = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
+exports.createHarness = exports.ComponentTestHarness = exports.invokeDataSource = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
 const jest_mock_1 = require("jest-mock");
 const createConnection = ({ key }, values) => ({
     configVarKey: "",
@@ -37,6 +37,30 @@ const loggerMock = () => ({
     error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
+const baseActionContext = {
+    logger: (0, exports.loggerMock)(),
+    instanceState: {},
+    crossFlowState: {},
+    executionState: {},
+    stepId: "mockStepId",
+    executionId: "mockExecutionId",
+    webhookUrls: {
+        "Flow 1": "https://example.com",
+    },
+    webhookApiKeys: {
+        "Flow 1": ["example-123", "example-456"],
+    },
+    invokeUrl: "https://example.com",
+    customer: {
+        id: "customerId",
+        name: "Customer 1",
+        externalId: "1234",
+    },
+    instance: {
+        id: "instanceId",
+        name: "Instance 1",
+    },
+};
 /**
  * Invokes specified ActionDefinition perform function using supplied params
  * and optional context. Accepts a generic type matching ActionPerformReturn as a convenience
@@ -44,18 +68,7 @@ exports.loggerMock = loggerMock;
  * action result and a mock logger for asserting logging.
  */
 const invoke = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-            "Flow 1": "https://example.com",
-        }, webhookApiKeys: {
-            "Flow 1": ["example-123", "example-456"],
-        }, invokeUrl: "https://example.com", customer: {
-            id: "customerId",
-            name: "Customer 1",
-            externalId: "1234",
-        }, instance: {
-            id: "instanceId",
-            name: "Instance 1",
-        } }, context);
+    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
     const result = yield perform(realizedContext, params);
     return {
         result,
@@ -107,18 +120,7 @@ exports.defaultTriggerPayload = defaultTriggerPayload;
  * trigger result and a mock logger for asserting logging.
  */
 const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-            "Flow 1": "https://example.com",
-        }, webhookApiKeys: {
-            "Flow 1": ["example-123", "example-456"],
-        }, invokeUrl: "https://example.com", customer: {
-            id: "customerId",
-            name: "Customer 1",
-            externalId: "1234",
-        }, instance: {
-            id: "instanceId",
-            name: "Instance 1",
-        } }, context);
+    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const realizedParams = params || {};
     const result = yield perform(realizedContext, realizedPayload, realizedParams);
@@ -128,10 +130,40 @@ const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void
     };
 });
 exports.invokeTrigger = invokeTrigger;
+const baseDataSourceContext = {
+    logger: (0, exports.loggerMock)(),
+    customer: {
+        id: "customerId",
+        name: "Customer 1",
+        externalId: "1234",
+    },
+    instance: {
+        id: "instanceId",
+        name: "Instance 1",
+    },
+};
+/**
+ * Invokes specified DataSourceDefinition perform function using supplied params.
+ * Accepts a generic type matching DataSourceResult as a convenience to avoid extra
+ * casting within test methods. Returns a DataSourceResult.
+ */
+const invokeDataSource = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = Object.assign(Object.assign({}, baseDataSourceContext), context);
+    const result = yield perform(realizedContext, params);
+    return result;
+});
+exports.invokeDataSource = invokeDataSource;
 class ComponentTestHarness {
     constructor(component) {
         this.component = component;
     }
+    buildContext(baseContext, context) {
+        return Object.assign(Object.assign({}, baseContext), context);
+    }
+    buildParams(inputs, params) {
+        const defaults = inputs.reduce((result, { key, default: defaultValue }) => (Object.assign(Object.assign({}, result), { [key]: `${defaultValue !== null && defaultValue !== void 0 ? defaultValue : ""}` })), {});
+        return Object.assign(Object.assign({}, defaults), params);
+    }
     connectionValue({ key }) {
         const { PRISMATIC_CONNECTION_VALUE: value } = process.env;
         if (!value) {
@@ -142,38 +174,20 @@ class ComponentTestHarness {
     }
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-                    "Flow 1": "https://example.com",
-                }, webhookApiKeys: {
-                    "Flow 1": ["example-123", "example-456"],
-                }, invokeUrl: "https://example.com", customer: {
-                    id: "customerId",
-                    name: "Customer 1",
-                    externalId: "1234",
-                }, instance: {
-                    id: "instanceId",
-                    name: "Instance 1",
-                } }, context);
             const trigger = this.component.triggers[key];
-            return trigger.perform(realizedContext, Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), Object.assign({}, params));
+            return trigger.perform(this.buildContext(baseActionContext, context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
         });
     }
     action(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-                    "Flow 1": "https://example.com",
-                }, webhookApiKeys: {
-                    "Flow 1": ["example-123", "example-456"],
-                }, invokeUrl: "https://example.com", customer: {
-                    id: "customerId",
-                    name: "Customer 1",
-                    externalId: "1234",
-                }, instance: {
-                    id: "instanceId",
-                    name: "Instance 1",
-                } }, context);
             const action = this.component.actions[key];
-            return action.perform(realizedContext, Object.assign({}, params));
+            return action.perform(this.buildContext(baseActionContext, context), this.buildParams(action.inputs, params));
+        });
+    }
+    dataSource(key, params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataSource = this.component.dataSources[key];
+            return dataSource.perform(this.buildContext(baseDataSourceContext, context), this.buildParams(dataSource.inputs, params));
         });
     }
 }
@@ -187,4 +201,5 @@ exports.default = {
     invoke: exports.invoke,
     invokeTrigger: exports.invokeTrigger,
     createHarness: exports.createHarness,
+    invokeDataSource: exports.invokeDataSource,
 };

package/dist/types/ActionPerformFunction.d.ts

@@ -1,4 +1,4 @@
-import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger } from ".";
+import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger, Instance, Customer } from ".";
 /** Definition of the function to perform when an Action is invoked. */
 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 */
@@ -21,15 +21,8 @@ export interface ActionContext {
     webhookApiKeys: Record<string, string[]>;
     /** The URL used to invoke the current execution */
     invokeUrl: string;
-    /** An object containing the ID, External ID and name of the customer the instance is deployed to */
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    /** An object containing the ID ad name of the currently running instance */
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    /** Contains attributes of the Customer for whom an Instance is being executed. */
+    customer: Customer;
+    /** Contains attributes of the Instance that is being executed. */
+    instance: Instance;
 }

package/dist/types/ActionPerformReturn.d.ts

@@ -12,7 +12,7 @@ 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. */
+    /** A field populated by the Prismatic platform which indicates whether the action 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>;

package/dist/types/ComponentDefinition.d.ts

@@ -1,4 +1,4 @@
-import { ActionDefinition, ConnectionDefinition, ComponentDisplayDefinition, TriggerDefinition } from ".";
+import { ActionDefinition, ConnectionDefinition, ComponentDisplayDefinition, TriggerDefinition, DataSourceDefinition } from ".";
 export declare type ErrorHandler = (error: unknown) => unknown;
 export interface ComponentHooks {
     /** Defines a global error handler that automatically wraps the component's action/trigger perform functions. */
@@ -16,6 +16,8 @@ export declare type ComponentDefinition<TPublic extends boolean> = {
     actions?: Record<string, ActionDefinition<any, boolean, any>>;
     /** Specifies the supported Triggers of this Component. */
     triggers?: Record<string, TriggerDefinition<any, boolean, any>>;
+    /** Specifies the supported Data Sources of this Component. */
+    dataSources?: Record<string, DataSourceDefinition<any, any>>;
     /** Specifies the supported Connections of this Component. */
     connections?: ConnectionDefinition[];
     /** Hooks */

package/dist/types/Customer.d.ts

@@ -0,0 +1,6 @@
+/** Contains attributes of the Customer for whom an Instance is being executed. */
+export interface Customer {
+    id: string;
+    externalId: string;
+    name: string;
+}

package/dist/types/Customer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/DataSourceDefinition.d.ts

@@ -0,0 +1,19 @@
+import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceType } from ".";
+/**
+ * DataSourceDefinition is the type of the object that is passed in to `dataSource` function to
+ * define a component Data Source.
+ */
+export interface DataSourceDefinition<TInputs extends Inputs, TDataSourceType extends DataSourceType> {
+    /** Defines how the Data Source is displayed in the Prismatic interface. */
+    display: ActionDisplayDefinition;
+    /** Function to perform when this Data Source is invoked; fetches data from the data source. */
+    perform: DataSourcePerformFunction<TInputs, TDataSourceType>;
+    /** The type of data that this Data Source represents. */
+    dataSourceType: TDataSourceType;
+    /** InputFields to present in the Prismatic interface for configuration of this Data Source. */
+    inputs: TInputs;
+    /** An example of the payload outputted by this Data Source. */
+    examplePayload?: Awaited<ReturnType<this["perform"]>>;
+    /** Specifies the name of a Data Source in this Component which can provide additional details about the content for this Data Source, such as example values when selecting particular API object fields. */
+    detailDataSource?: string;
+}

package/dist/types/DataSourceDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/DataSourcePerformFunction.d.ts

@@ -0,0 +1,9 @@
+import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ActionLogger, Customer, Instance } from ".";
+/** Context provided to perform method containing helpers and contextual data */
+export interface DataSourceContext {
+    logger: ActionLogger;
+    customer: Customer;
+    instance: Instance;
+}
+/** Definition of the function to perform when a Data Source is invoked. */
+export declare type DataSourcePerformFunction<TInputs extends Inputs, TDataSourceType extends DataSourceType> = (context: DataSourceContext, params: ActionInputParameters<TInputs>) => Promise<DataSourceResult<TDataSourceType>>;

package/dist/types/DataSourcePerformFunction.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/DataSourceResult.d.ts

@@ -0,0 +1,35 @@
+import { ConnectionDefinition } from "./ConnectionDefinition";
+import { ObjectSelection, ObjectFieldMap, JSONForm } from "./Inputs";
+/** The type of field that is appropriate for rendering the data that is the result of the data source perform function. */
+declare type DataSourceTypeMap = {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string[];
+    schedule: {
+        value: string;
+    };
+    code: string;
+    credential: unknown;
+    boolean: boolean;
+    number: number;
+    connection: ConnectionDefinition;
+    objectSelection: ObjectSelection;
+    objectFieldMap: ObjectFieldMap;
+    jsonForm: JSONForm;
+};
+export declare type DataSourceType = keyof DataSourceTypeMap;
+export declare type DataSourceResultType = DataSourceTypeMap[DataSourceType];
+/** Represents the result of a Data Source action. */
+export declare type DataSourceResult<TDataSourceType extends DataSourceType> = {
+    /** The resulting data that is returned from the data source. */
+    result: DataSourceTypeMap[TDataSourceType];
+    /** Additional data that may be useful for out-of-band processing at a later time.
+     *  NOTE: This is only available when the Data Source is called as part of fetching
+     *  contents for a Configuration Wizard Page. */
+    supplementalData?: {
+        data: unknown;
+        contentType: string;
+    };
+};
+export {};

package/dist/types/DataSourceResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/Inputs.d.ts

@@ -1,4 +1,33 @@
 import { ConditionalExpression } from "./conditional-logic";
+export declare type Element = {
+    key: string;
+    label?: string;
+};
+export declare type ObjectSelection = {
+    object: Element;
+    fields?: Element[];
+    defaultSelected?: boolean;
+}[];
+export declare type ObjectFieldMap = {
+    fields: {
+        field: Element;
+        mappedObject?: Element;
+        mappedField?: Element;
+        defaultObject?: Element;
+        defaultField?: Element;
+    }[];
+    options?: {
+        object: Element;
+        fields: Element[];
+    }[];
+};
+export declare type JSONForm = {
+    schema: Record<string, unknown>;
+    uiSchema: Record<string, unknown>;
+    data: unknown;
+};
+export declare type DynamicObjectSelection = string;
+export declare type DynamicFieldSelection = string;
 /** InputField type enumeration. */
 export declare type InputFieldType = InputFieldDefinition["type"];
 export declare const InputFieldDefaultMap: Record<InputFieldType, string | undefined>;
@@ -6,7 +35,7 @@ export declare type Inputs = Record<string, InputFieldDefinition>;
 export declare type ConnectionInput = (StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField) & {
     shown?: boolean;
 };
-export declare type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField;
+export declare type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField | ObjectSelectionInputField | ObjectFieldMapInputField | JSONFormInputField | DynamicObjectSelectionInputField | DynamicFieldSelectionInputField;
 export declare type InputCleanFunction<TValue, TResult = TValue> = (value: TValue) => TResult;
 interface BaseInputField {
     /** Interface label of the InputField. */
@@ -132,6 +161,61 @@ export interface Connection {
     token?: Record<string, unknown>;
     context?: Record<string, unknown>;
 }
+/** Defines attributes of an ObjectSelectionInputField. */
+export interface ObjectSelectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "objectSelection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: ObjectSelection;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of an ObjectFieldMapInputField. */
+export interface ObjectFieldMapInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "objectFieldMap";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: ObjectFieldMap;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of a JSONFormInputField. */
+export interface JSONFormInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "jsonForm";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: JSONForm;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of a DynamicObjectSelectionInputField */
+export interface DynamicObjectSelectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "dynamicObjectSelection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of a SelectedFieldInputField */
+export interface DynamicFieldSelectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "dynamicFieldSelection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
 /** Defines a single Choice option for a InputField. */
 export interface InputFieldChoice {
     /** Label to display for this Choice. */

package/dist/types/Inputs.js

@@ -10,4 +10,9 @@ exports.InputFieldDefaultMap = {
     code: "",
     conditional: undefined,
     connection: undefined,
+    objectSelection: undefined,
+    objectFieldMap: undefined,
+    jsonForm: undefined,
+    dynamicObjectSelection: "",
+    dynamicFieldSelection: "",
 };

package/dist/types/Instance.d.ts

@@ -0,0 +1,5 @@
+/** Contains attributes of the Instance that is being executed. */
+export interface Instance {
+    id: string;
+    name: string;
+}

package/dist/types/Instance.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/TriggerPayload.d.ts

@@ -1,3 +1,4 @@
+import { Instance, Customer } from ".";
 /** Represents a Trigger Payload, which is data passed into a Trigger to invoke an Integration execution. */
 export interface TriggerPayload {
     headers: {
@@ -27,13 +28,8 @@ export interface TriggerPayload {
     /** The URL that was used to invoke the execution. */
     invokeUrl: string;
     executionId: string;
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    /** Contains attributes of the Customer for whom an Instance is being executed. */
+    customer: Customer;
+    /** Contains attributes of the Instance that is being executed. */
+    instance: Instance;
 }

package/dist/types/index.d.ts

@@ -18,3 +18,9 @@ export * from "./TriggerPerformFunction";
 export * from "./TriggerDefinition";
 export * from "./HttpResponse";
 export * from "./TriggerPayload";
+export * from "./DataSourceDefinition";
+export * from "./DataSourcePerformFunction";
+export * from "./DataSourceResult";
+export * from "./Instance";
+export * from "./Customer";
+export * as serverTypes from "../serverTypes";

package/dist/types/index.js

@@ -14,10 +14,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 __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);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverTypes = void 0;
 __exportStar(require("./ActionDefinition"), exports);
 __exportStar(require("./ComponentDefinition"), exports);
 __exportStar(require("./ConnectionDefinition"), exports);
@@ -34,3 +47,9 @@ __exportStar(require("./TriggerPerformFunction"), exports);
 __exportStar(require("./TriggerDefinition"), exports);
 __exportStar(require("./HttpResponse"), exports);
 __exportStar(require("./TriggerPayload"), exports);
+__exportStar(require("./DataSourceDefinition"), exports);
+__exportStar(require("./DataSourcePerformFunction"), exports);
+__exportStar(require("./DataSourceResult"), exports);
+__exportStar(require("./Instance"), exports);
+__exportStar(require("./Customer"), exports);
+exports.serverTypes = __importStar(require("../serverTypes"));

package/dist/util.d.ts

@@ -3,7 +3,7 @@
  * Many functions in the `util` module are used to coerce data into a particular type, and can be accessed through `util.types`.
  * For example, `util.types.toInt("5.5")` will return an integer, `5`.
  */
-import { KeyValuePair, DataPayload } from "./types";
+import { KeyValuePair, DataPayload, ObjectSelection, ObjectFieldMap, JSONForm, ConnectionDefinition } from "./types";
 /**
  * This function returns a lower cased version of the headers passed to it.
  *
@@ -31,11 +31,21 @@ declare const _default: {
         toBufferDataPayload: (value: unknown) => DataPayload;
         isData: (value: unknown) => boolean;
         toData: (value: unknown) => DataPayload;
+        isString: (value: unknown) => value is string;
         toString: (value: unknown, defaultValue?: string) => string;
         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>;
+        isObjectSelection: (value: unknown) => value is ObjectSelection;
+        toObjectSelection: (value: unknown) => ObjectSelection;
+        isObjectFieldMap: (value: unknown) => value is ObjectFieldMap;
+        toObjectFieldMap: (value: unknown) => ObjectFieldMap;
+        isJSONForm: (value: unknown) => value is JSONForm;
+        toJSONForm: (value: unknown) => JSONForm;
+        isPicklist: (value: unknown) => boolean;
+        isSchedule: (value: unknown) => boolean;
+        isConnection: (value: unknown) => value is ConnectionDefinition;
     };
     docs: {
         formatJsonExample: (input: unknown) => string;

package/dist/util.js

@@ -15,6 +15,92 @@ const isValid_1 = __importDefault(require("date-fns/isValid"));
 const isDate_1 = __importDefault(require("date-fns/isDate"));
 const safe_stable_stringify_1 = require("safe-stable-stringify");
 const valid_url_1 = require("valid-url");
+const isObjectWithTruthyKeys = (value, keys) => {
+    return (value !== null &&
+        typeof value === "object" &&
+        keys.every((key) => key in value && Boolean(value === null || value === void 0 ? void 0 : value[key])));
+};
+/**
+ * @param value The value to test
+ * @returns This function returns true if the type of `value` is an ObjectSelection, or false otherwise.
+ */
+const isObjectSelection = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isObjectSelection(JSON.parse(value));
+    }
+    return (Array.isArray(value) &&
+        value.every((item) => isObjectWithTruthyKeys(item, ["object"])));
+};
+/**
+ * This function coerces a provided value into an ObjectSelection if possible.
+ * @param value The value to coerce to ObjectSelection.
+ * @returns This function returns the the value as an ObjectSelection if possible.
+ */
+const toObjectSelection = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toObjectSelection(JSON.parse(value));
+    }
+    if (isObjectSelection(value)) {
+        return value;
+    }
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to ObjectSelection.`);
+};
+/**
+ * @param value The value to test
+ * @returns This function returns true if the type of `value` is an ObjectFieldMap, or false otherwise.
+ */
+const isObjectFieldMap = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isObjectFieldMap(JSON.parse(value));
+    }
+    if (Boolean(value) && typeof value === "object") {
+        const { fields } = value;
+        return (Array.isArray(fields) &&
+            fields.every((item) => isObjectWithTruthyKeys(item, ["field"]) &&
+                isObjectWithTruthyKeys(item === null || item === void 0 ? void 0 : item.field, [
+                    "key",
+                ])));
+    }
+    return false;
+};
+/**
+ * This function coerces a provided value into an ObjectFieldMap if possible.
+ * @param value The value to coerce to ObjectFieldMap.
+ * @returns This function returns the the value as an ObjectFieldMap if possible.
+ */
+const toObjectFieldMap = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toObjectFieldMap(JSON.parse(value));
+    }
+    if (isObjectFieldMap(value)) {
+        return value;
+    }
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to ObjectFieldMap.`);
+};
+/**
+ * @param value The value to test
+ * @returns This function returns true if the type of `value` is a JSONForm, or false otherwise.
+ */
+const isJSONForm = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isJSONForm(JSON.parse(value));
+    }
+    return isObjectWithTruthyKeys(value, ["schema", "uiSchema", "data"]);
+};
+/**
+ * This function coerces a provided value into a JSONForm if possible.
+ * @param value The value to coerce to JSONForm.
+ * @returns This function returns the the value as a JSONForm if possible.
+ */
+const toJSONForm = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toJSONForm(JSON.parse(value));
+    }
+    if (isJSONForm(value)) {
+        return value;
+    }
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to JSONForm.`);
+};
 /**
  * Determine if a variable is a boolean (true or false).
  *
@@ -187,6 +273,25 @@ const toDate = (value) => {
  * @returns This function returns true if `value` is a valid URL, and false otherwise.
  */
 const isUrl = (value) => (0, valid_url_1.isWebUri)(value) !== undefined;
+/**
+ * This function checks if value is a valid picklist.
+ *
+ * - `util.types.isPicklist(["value", new String("value")])` will return `true`.
+ *
+ * @param value The variable to test.
+ * @returns This function returns true if `value` is a valid picklist.
+ */
+const isPicklist = (value) => Array.isArray(value) && value.every(isString);
+/**
+ * This function checks if value is a valid schedule.
+ *
+ * - `util.types.isSchedule({value: "00 00 * * 2,3"})` will return `true`.
+ * - `util.types.isSchedule({value: "00 00 * * 2,3", scheduleType: "week", timeZone: "America/Chicago"})` will return `true`.
+ *
+ * @param value The variable to test.
+ * @returns This function returns true if `value` is a valid schedule.
+ */
+const isSchedule = (value) => isObjectWithTruthyKeys(value, ["value"]);
 /**
  * This function helps to transform key-value lists to objects.
  * This is useful for transforming inputs that are key-value collections into objects.
@@ -280,6 +385,13 @@ const toData = (value) => toBufferDataPayload(value);
  * @returns This function returns a code block that can be used for documentation.
  */
 const formatJsonExample = (input) => ["```json", JSON.stringify(input, undefined, 2), "```"].join("\n");
+/**
+ * This function checks if value is a string.
+ * `util.types.isString("value")` and `util.types.isString(new String("value"))` return true.
+ * @param value The variable to test.
+ * @returns This function returns true or false, depending on if `value` is a string.
+ */
+const isString = (value) => typeof value === "string" || value instanceof String;
 /**
  * This function converts a `value` to a string.
  * If `value` is undefined or an empty string, an optional `defaultValue` can be returned.
@@ -293,6 +405,31 @@ const formatJsonExample = (input) => ["```json", JSON.stringify(input, undefined
  * @returns This function returns the stringified version fo `value`, or `defaultValue` in the case that `value` is undefined or an empty string.
  */
 const toString = (value, defaultValue = "") => `${value !== null && value !== void 0 ? value : defaultValue}`;
+/**
+ * This function checks if value is a valid connection.
+ * @param value The variable to test.
+ * @returns This function returns true or false, depending on if `value` is a valid connection.
+ */
+const isConnection = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isConnection(JSON.parse(value));
+    }
+    if (Boolean(value) && typeof value === "object") {
+        const { inputs } = value;
+        if (isObjectWithTruthyKeys(value, ["key", "label", "oauth2Type"])) {
+            return (isObjectWithTruthyKeys(inputs, [
+                "authorizeUrl",
+                "tokenUrl",
+                "clientId",
+                "clientSecret",
+            ]) ||
+                isObjectWithTruthyKeys(inputs, ["tokenUrl", "clientId", "clientSecret"]));
+        }
+        return (isObjectWithTruthyKeys(value, ["key", "label"]) &&
+            typeof inputs === "object");
+    }
+    return false;
+};
 /**
  * This function returns true if `value` resembles the shape of JSON, and false otherwise.
  *
@@ -352,11 +489,21 @@ exports.default = {
         toBufferDataPayload,
         isData,
         toData,
+        isString,
         toString,
         keyValPairListToObject,
         isJSON,
         toJSON,
         lowerCaseHeaders: exports.lowerCaseHeaders,
+        isObjectSelection,
+        toObjectSelection,
+        isObjectFieldMap,
+        toObjectFieldMap,
+        isJSONForm,
+        toJSONForm,
+        isPicklist,
+        isSchedule,
+        isConnection,
     },
     docs: {
         formatJsonExample,

package/package.json

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