@prismatic-io/spectral 7.8.4 → 8.0.0-preview10

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

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/serverTypes/convert.d.ts

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

package/dist/serverTypes/convert.js

@@ -10,8 +10,13 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertComponent = void 0;
+exports.convertIntegration = exports.convertComponent = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+const uuid_1 = require("uuid");
 const types_1 = require("../types");
 const perform_1 = require("./perform");
 const convertInput = (key, _a) => {
@@ -77,3 +82,244 @@ const convertComponent = (_a) => {
     return Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: convertedActions, triggers: convertedTriggers, dataSources: convertedDataSources });
 };
 exports.convertComponent = convertComponent;
+const convertIntegration = (definition) => {
+    // Generate a unique reference key that will be used to reference the
+    // actions, triggers, data sources, and connections that are created
+    // inline as part of the integration definition.
+    const referenceKey = (0, uuid_1.v4)();
+    return Object.assign(Object.assign({}, codeNativeIntegrationComponent(definition, referenceKey)), { codeNativeIntegrationYAML: codeNativeIntegrationYaml(definition, referenceKey) });
+};
+exports.convertIntegration = convertIntegration;
+const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, configVars, endpointType, triggerPreprocessFlowConfig, flows, configPages, }, referenceKey) => {
+    const DEFINITION_VERSION = 7;
+    // Find the preprocess flow config on the flow, if one exists.
+    const preprocessFlows = flows.filter((flow) => flow.preprocessFlowConfig);
+    // Do some validation of preprocess flow configs.
+    if (preprocessFlows.length > 1) {
+        throw new Error("Only one flow may define a Preprocess Flow Config.");
+    }
+    if (preprocessFlows.length && triggerPreprocessFlowConfig) {
+        throw new Error("Integration must not define both a Trigger Preprocess Flow Config and a Preprocess Flow.");
+    }
+    const hasPreprocessFlow = preprocessFlows.length > 0;
+    const preprocessFlowConfig = hasPreprocessFlow
+        ? preprocessFlows[0].preprocessFlowConfig
+        : triggerPreprocessFlowConfig;
+    if ([types_1.EndpointType.InstanceSpecific, types_1.EndpointType.SharedInstance].includes(endpointType || types_1.EndpointType.FlowSpecific) &&
+        !preprocessFlowConfig) {
+        throw new Error("Integration with specified EndpointType must define either a Trigger Preprocess Flow Config or a Preprocess Flow.");
+    }
+    // Transform the IntegrationDefinition into the structure that is appropriate
+    // for generating YAML, which will then be used by the Prismatic API to import
+    // the integration as a Code Native Integration.
+    const result = {
+        definitionVersion: DEFINITION_VERSION,
+        isCodeNative: true,
+        name,
+        description,
+        category,
+        documentation,
+        version,
+        labels,
+        requiredConfigVars: Object.entries(configVars || {}).map(([key, configVar]) => convertConfigVar(Object.assign(Object.assign({}, configVar), { key }), referenceKey)),
+        endpointType,
+        preprocessFlowName: hasPreprocessFlow ? preprocessFlows[0].name : undefined,
+        externalCustomerIdField: fieldNameToReferenceInput(hasPreprocessFlow ? "onExecution" : "payload", preprocessFlowConfig === null || preprocessFlowConfig === void 0 ? void 0 : preprocessFlowConfig.externalCustomerIdField),
+        externalCustomerUserIdField: fieldNameToReferenceInput(hasPreprocessFlow ? "onExecution" : "payload", preprocessFlowConfig === null || preprocessFlowConfig === void 0 ? void 0 : preprocessFlowConfig.externalCustomerUserIdField),
+        flowNameField: fieldNameToReferenceInput(hasPreprocessFlow ? "onExecution" : "payload", preprocessFlowConfig === null || preprocessFlowConfig === void 0 ? void 0 : preprocessFlowConfig.flowNameField),
+        flows: flows.map((flow) => convertFlow(flow, referenceKey)),
+        configPages,
+    };
+    return yaml_1.default.stringify(result);
+};
+/** Converts a Flow into the structure necessary for YAML generation. */
+const convertFlow = (flow, referenceKey) => {
+    const result = Object.assign({}, flow);
+    delete result.onTrigger;
+    delete result.trigger;
+    delete result.onInstanceDeploy;
+    delete result.onInstanceDelete;
+    delete result.onExecution;
+    delete result.preprocessFlowConfig;
+    delete result.errorConfig;
+    const triggerStep = {
+        name: "On Trigger",
+        description: "The function that will be executed by the flow to return an HTTP response.",
+        isTrigger: true,
+        errorConfig: "errorConfig" in flow ? Object.assign({}, flow.errorConfig) : undefined,
+        action: {
+            key: flowFunctionKey(flow.name, "onTrigger"),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        },
+    };
+    if ("schedule" in flow && typeof flow.schedule === "object") {
+        triggerStep.schedule = {
+            type: "cronExpression" in flow.schedule
+                ? types_1.SimpleInputValueType.Value
+                : types_1.SimpleInputValueType.ConfigVar,
+            value: "cronExpression" in flow.schedule
+                ? flow.schedule.cronExpression
+                : flow.schedule.configVarKey,
+            meta: {
+                scheduleType: types_1.ScheduleType.Custom,
+                timeZone: flow.schedule.timeZone,
+            },
+        };
+        delete result.schedule;
+    }
+    const actionStep = {
+        action: {
+            key: flowFunctionKey(flow.name, "onExecution"),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        },
+        name: "On Execution",
+        description: "The function that will be executed by the flow.",
+        errorConfig: "errorConfig" in flow ? Object.assign({}, flow.errorConfig) : undefined,
+    };
+    result.steps = [triggerStep, actionStep];
+    return result;
+};
+/** Converts a Config Var into the structure necessary for YAML generation. */
+const convertConfigVar = (configVar, referenceKey) => {
+    // This is unfortunate but we need to strip out some fields that are not
+    // relevant to config vars.
+    const fields = [
+        "key",
+        "description",
+        "orgOnly",
+        "inputs",
+        "defaultValue",
+        "dataType",
+        "pickList",
+        "scheduleType",
+        "timeZone",
+        "codeLanguage",
+        "collectionType",
+        "dataSource",
+    ];
+    const result = Object.entries(configVar).reduce((result, [key, value]) => {
+        if (!fields.includes(key)) {
+            return result;
+        }
+        return Object.assign(Object.assign({}, result), { [key]: value });
+    }, { meta: {} });
+    // Handle some non-standard fields.
+    if ("visibleToOrgDeployer" in configVar) {
+        result.meta.visibleToOrgDeployer = configVar.visibleToOrgDeployer;
+    }
+    if ("visibleToCustomerDeployer" in configVar) {
+        result.meta.visibleToCustomerDeployer = configVar.visibleToCustomerDeployer;
+    }
+    // Handle connections.
+    if ("label" in configVar) {
+        result.dataType = "connection";
+        // This refers to a connection we are creating.
+        result.connection = {
+            key: configVar.key,
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+        result.description = configVar.label;
+        // Convert connection inputs to the inputs expected in the YAML.
+        // FIXME: This is just a placeholder for now.
+        // TODO: It seems like using the default value as the value is probably correct?
+        result.inputs = Object.entries(configVar.inputs).reduce((result, [key, input]) => {
+            var _a;
+            return Object.assign(Object.assign({}, result), { [key]: {
+                    type: types_1.SimpleInputValueType.Value,
+                    value: (_a = input.default) !== null && _a !== void 0 ? _a : "",
+                } });
+        }, {});
+    }
+    // Handle data source references.
+    if ("dataSource" in result) {
+        // This is a reference to a data source we are creating.
+        result.dataSource = {
+            key: result.dataSource,
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+    }
+    return result;
+};
+/** Maps the step name field to a fully qualified input. */
+const fieldNameToReferenceInput = (stepName, fieldName) => {
+    if (!fieldName) {
+        return undefined;
+    }
+    return {
+        type: types_1.SimpleInputValueType.Reference,
+        value: `${stepName}.results.${fieldName}`,
+    };
+};
+/** Actions and Triggers will be scoped to their flow by combining the flow
+ *  name and the function name. This is to ensure that the keys are unique
+ *  on the resulting object, which will be turned into a Component. */
+const flowFunctionKey = (flowName, functionName) => {
+    const flowKey = flowName
+        .replace(/[^0-9a-zA-Z]+/g, " ")
+        .trim()
+        .split(" ")
+        .map((w, i) => i === 0
+        ? w.toLowerCase()
+        : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join("");
+    return `${flowKey}_${functionName}`;
+};
+/** Creates the structure necessary to import a Component as part of a
+ *  Code Native integration. */
+const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], dataSources = {}, configVars = {}, }, referenceKey) => {
+    const convertedActions = flows.reduce((result, { name, onExecution }) => {
+        const actionKey = flowFunctionKey(name, "onExecution");
+        return Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, {
+                display: {
+                    label: `${name} - onExecution`,
+                    description: "The function that will be executed by the flow.",
+                },
+                perform: onExecution,
+                inputs: {},
+            }) });
+    }, {});
+    const convertedTriggers = flows.reduce((result, flow) => {
+        // Filter out TriggerReferences.
+        if ("trigger" in flow)
+            return result;
+        const { name, onTrigger, onInstanceDeploy, onInstanceDelete } = flow;
+        const triggerKey = flowFunctionKey(name, "onTrigger");
+        return Object.assign(Object.assign({}, result), { [triggerKey]: convertTrigger(triggerKey, {
+                display: {
+                    label: `${name} - onTrigger`,
+                    description: "The function that will be executed by the flow to return an HTTP response.",
+                },
+                perform: onTrigger,
+                onInstanceDeploy: onInstanceDeploy,
+                onInstanceDelete: onInstanceDelete,
+                inputs: {},
+                scheduleSupport: "valid",
+                synchronousResponseSupport: "valid",
+            }) });
+    }, {});
+    const convertedDataSources = Object.entries(dataSources).reduce((result, [dataSourceKey, dataSource]) => (Object.assign(Object.assign({}, result), { [dataSourceKey]: convertDataSource(dataSourceKey, Object.assign(Object.assign({}, dataSource), { inputs: {} })) })), {});
+    const convertedConnections = Object.entries(configVars).reduce((result, [key, configVar]) => {
+        if (!("label" in configVar)) {
+            return result;
+        }
+        // Remove a few fields that are not relevant to connections.
+        const { 
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        orgOnly, visibleToOrgDeployer, visibleToCustomerDeployer } = configVar, 
+        /* eslint-enable @typescript-eslint/no-unused-vars */
+        connection = __rest(configVar, ["orgOnly", "visibleToOrgDeployer", "visibleToCustomerDeployer"]);
+        return [...result, convertConnection(Object.assign(Object.assign({}, connection), { key }))];
+    }, []);
+    return {
+        key: referenceKey,
+        display: {
+            label: referenceKey,
+            iconPath,
+            description: description || name,
+        },
+        connections: convertedConnections,
+        actions: convertedActions,
+        triggers: convertedTriggers,
+        dataSources: convertedDataSources,
+    };
+};

package/dist/serverTypes/index.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="node" />
-import { Instance, Customer, DataSourceType, DataSourceResultType, User, TriggerEventFunctionReturn, Integration, Flow } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
 }
-export { Instance } from "../types";
-export { Customer } from "../types";
-export { User } from "../types";
-export { Integration } from "../types";
-export { Flow } from "../types";
+export { InstanceAttributes } from "../types";
+export { CustomerAttributes } from "../types";
+export { UserAttributes } from "../types";
+export { IntegrationAttributes } from "../types";
+export { FlowAttributes } from "../types";
 export interface Component {
     key: string;
     public?: boolean;
@@ -21,6 +21,7 @@ export interface Component {
     triggers: Record<string, Trigger>;
     dataSources: Record<string, DataSource>;
     connections: Connection[];
+    codeNativeIntegrationYAML?: string;
 }
 export interface Action {
     key: string;
@@ -47,7 +48,7 @@ export interface ActionLogger {
     warn: ActionLoggerFunction;
     error: ActionLoggerFunction;
 }
-export interface ActionContext {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection, THasConfigVars extends boolean = false> = {
     logger: ActionLogger;
     instanceState: Record<string, unknown>;
     crossFlowState: Record<string, unknown>;
@@ -58,13 +59,15 @@ export interface ActionContext {
     webhookUrls: Record<string, string>;
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
-    customer: Customer;
-    instance: Instance;
-    user: User;
-    integration: Integration;
-    flow: Flow;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
+    integration: IntegrationAttributes;
+    flow: FlowAttributes;
     startedAt: string;
-}
+} & (THasConfigVars extends true ? {
+    configVars: TConfigVars;
+} : Record<string, never>);
 declare type TriggerOptionChoice = "invalid" | "valid" | "required";
 export interface TriggerPayload {
     headers: Record<string, string>;
@@ -82,11 +85,11 @@ export interface TriggerPayload {
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
     executionId: string;
-    customer: Customer;
-    instance: Instance;
-    user: User;
-    integration: Integration;
-    flow: Flow;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
+    integration: IntegrationAttributes;
+    flow: FlowAttributes;
     startedAt: string;
 }
 interface HttpResponse {
@@ -109,9 +112,9 @@ interface TriggerBranchingResult extends TriggerBaseResult {
     branch: string;
 }
 export declare type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
-export declare type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
+export declare type TriggerPerformFunction = (context: ActionContext<any>, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
 export declare type TriggerEventFunctionResult = TriggerEventFunctionReturn | void;
-export declare type TriggerEventFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
+export declare type TriggerEventFunction = (context: ActionContext<any>, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
 export interface Trigger {
     key: string;
     display: DisplayDefinition & {
@@ -136,9 +139,9 @@ export interface Trigger {
 }
 export interface DataSourceContext {
     logger: ActionLogger;
-    customer: Customer;
-    instance: Instance;
-    user: User;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
 }
 export declare type DataSourceResult = {
     result: DataSourceResultType;
@@ -211,7 +214,7 @@ interface ServerPerformBranchingDataReturn extends ServerPerformDataReturn {
     branch: string;
 }
 export declare type ActionPerformReturn = ServerPerformDataStructureReturn | ServerPerformBranchingDataStructureReturn | ServerPerformDataReturn | ServerPerformBranchingDataReturn | undefined;
-export declare type ActionPerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
+export declare type ActionPerformFunction = (context: ActionContext<any>, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
 interface InputFieldChoice {
     label: string;
     value: string;

package/dist/testing.d.ts

@@ -5,7 +5,7 @@
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
 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, TriggerEventFunctionReturn } from "./types";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow, ConfigVarResultCollection, ConfigVarCollection, ConfigVarDefinitionsToResults } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>, tokenValues?: Record<string, unknown> | undefined) => ConnectionValue;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
@@ -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: <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 invoke: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform, }: ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext<TConfigVars, false>> | 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: <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 const invokeTrigger: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TriggerPayload>>({ perform, }: TriggerDefinition<TInputs, TConfigVars, TAllowsBranching, TResult>, context?: Partial<ActionContext<TConfigVars, false>> | 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
@@ -56,23 +56,28 @@ export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType
     objectFieldMap: import("./types").ObjectFieldMap;
     jsonForm: import("./types").JSONForm;
 }>({ perform }: DataSourceDefinition<TInputs, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+/**
+ * Invokes specified Flow of a Code Native Integration using supplied params.
+ * Runs the Trigger and then the Action function and returns the result of the Action.
+ */
+export declare const invokeFlow: <TConfigVars extends ConfigVarCollection>(flow: Flow<TConfigVars, import("./types").TriggerPayload>, context?: Partial<ActionContext<ConfigVarDefinitionsToResults<TConfigVars>, true>> | undefined, payload?: TriggerPayload | undefined) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
 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>;
-    triggerOnInstanceDeploy(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<void | TriggerEventFunctionReturn>;
-    triggerOnInstanceDelete(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<void | TriggerEventFunctionReturn>;
-    action(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<ActionPerformReturn>;
+    trigger<TConfigVars extends ConfigVarResultCollection>(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<TriggerResult>;
+    triggerOnInstanceDeploy<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<void | TriggerEventFunctionReturn>;
+    triggerOnInstanceDelete<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<void | TriggerEventFunctionReturn>;
+    action<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): 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: {
     loggerMock: () => ActionLogger;
-    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>>;
+    invoke: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform, }: ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext<TConfigVars, false>> | undefined) => Promise<InvokeReturn<TReturn>>;
+    invokeTrigger: <TInputs_1 extends Inputs, TConfigVars_1 extends ConfigVarResultCollection, TAllowsBranching_1 extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching_1, TriggerPayload>>({ perform, }: TriggerDefinition<TInputs_1, TConfigVars_1, TAllowsBranching_1, TResult>, context?: Partial<ActionContext<TConfigVars_1, false>> | 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;