@prismatic-io/spectral 8.0.0 → 8.0.2

package/dist/serverTypes/convertIntegration.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertIntegration = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+const uuid_1 = require("uuid");
+const lodash_1 = require("lodash");
+const types_1 = require("../types");
+const convert_1 = require("./convert");
+const integration_1 = require("./integration");
+const convertIntegration = (definition) => {
+    var _a;
+    // 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)();
+    const configVars = Object.assign({}, ...Object.values((_a = definition.configPages) !== null && _a !== void 0 ? _a : {}).map(({ elements }) => elements));
+    return Object.assign(Object.assign({}, codeNativeIntegrationComponent(definition, referenceKey, configVars)), { codeNativeIntegrationYAML: codeNativeIntegrationYaml(definition, referenceKey, configVars) });
+};
+exports.convertIntegration = convertIntegration;
+const convertConfigPages = (pages) => {
+    if (!pages || !Object.keys(pages).length) {
+        return;
+    }
+    return Object.entries(pages).map(([name, { tagline, elements }]) => ({
+        name,
+        tagline,
+        elements: Object.keys(elements).map((key) => ({
+            type: "configVar",
+            value: key,
+        })),
+    }));
+};
+const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, endpointType, triggerPreprocessFlowConfig, flows, configPages, }, referenceKey, configVars) => {
+    // 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: integration_1.DefinitionVersion,
+        isCodeNative: true,
+        name,
+        description,
+        category,
+        documentation,
+        version,
+        labels,
+        requiredConfigVars: Object.entries(configVars || {}).map(([key, configVar]) => convertConfigVar(key, configVar, 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: convertConfigPages(configPages !== null && configPages !== void 0 ? 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",
+        stableKey: `${flow.stableKey}-onTrigger`,
+        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 ? "value" : "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",
+        stableKey: `${flow.stableKey}-onExecution`,
+        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 = (key, configVar, referenceKey) => {
+    const meta = (0, lodash_1.pick)(configVar, [
+        "visibleToCustomerDeployer",
+        "visibleToOrgDeployer",
+    ]);
+    if ((0, types_1.isConnectionConfigVar)(configVar)) {
+        return Object.assign(Object.assign({}, (0, lodash_1.pick)(configVar, ["stableKey", "description", "orgOnly"])), { key, dataType: "connection", connection: {
+                component: { key: referenceKey, version: "LATEST", isPublic: false },
+                key: (0, lodash_1.camelCase)(key),
+            }, inputs: Object.entries(configVar.inputs).reduce((result, [key, input]) => {
+                if (!input.shown || !input.default) {
+                    return result;
+                }
+                return Object.assign(Object.assign({}, result), { [key]: { type: "value", value: input.default } });
+            }, {}), meta });
+    }
+    const result = (0, lodash_1.assign)({ meta, key }, (0, lodash_1.pick)(configVar, [
+        "stableKey",
+        "description",
+        "orgOnly",
+        "defaultValue",
+        "dataType",
+        "pickList",
+        "scheduleType",
+        "timeZone",
+        "codeLanguage",
+        "collectionType",
+    ]));
+    // Handle data sources.
+    if ((0, types_1.isDataSourceConfigVar)(configVar)) {
+        result.dataType = configVar.dataSourceType;
+        result.dataSource = {
+            key: (0, lodash_1.camelCase)(key),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+    }
+    return result;
+};
+/** Maps the step name field to a fully qualified input. */
+const fieldNameToReferenceInput = (stepName, fieldName) => fieldName
+    ? { type: "reference", value: `${stepName}.results.${fieldName}` }
+    : undefined;
+/** 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 = [], }, referenceKey, configVars) => {
+    const convertedActions = flows.reduce((result, { name, onExecution }) => {
+        const key = flowFunctionKey(name, "onExecution");
+        return Object.assign(Object.assign({}, result), { [key]: {
+                key,
+                display: {
+                    label: `${name} - onExecution`,
+                    description: "The function that will be executed by the flow.",
+                },
+                perform: onExecution,
+                inputs: [],
+            } });
+    }, {});
+    const convertedTriggers = flows.reduce((result, { name, onTrigger, onInstanceDeploy, onInstanceDelete }) => {
+        const key = flowFunctionKey(name, "onTrigger");
+        return Object.assign(Object.assign({}, result), { [key]: {
+                key,
+                display: {
+                    label: `${name} - onTrigger`,
+                    description: "The function that will be executed by the flow to return an HTTP response.",
+                },
+                perform: onTrigger,
+                onInstanceDeploy,
+                hasOnInstanceDeploy: !!onInstanceDeploy,
+                onInstanceDelete,
+                hasOnInstanceDelete: !!onInstanceDelete,
+                inputs: [],
+                scheduleSupport: "valid",
+                synchronousResponseSupport: "valid",
+            } });
+    }, {});
+    const convertedDataSources = Object.entries(configVars).reduce((result, [key, configVar]) => {
+        if (!(0, types_1.isDataSourceConfigVar)(configVar)) {
+            return result;
+        }
+        const dataSource = (0, lodash_1.pick)(configVar, ["perform", "dataSourceType"]);
+        return Object.assign(Object.assign({}, result), { [key]: Object.assign(Object.assign({}, dataSource), { key: (0, lodash_1.camelCase)(key), display: {
+                    label: key,
+                    description: key,
+                }, inputs: [] }) });
+    }, {});
+    const convertedConnections = Object.entries(configVars).reduce((result, [key, configVar]) => {
+        if (!(0, types_1.isConnectionConfigVar)(configVar)) {
+            return result;
+        }
+        const convertedInputs = Object.entries(configVar.inputs).map(([key, value]) => (0, convert_1.convertInput)(key, value));
+        const connection = (0, lodash_1.pick)(configVar, ["oauth2Type", "iconPath"]);
+        return [
+            ...result,
+            Object.assign(Object.assign({}, connection), { inputs: convertedInputs, key: (0, lodash_1.camelCase)(key), label: 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

@@ -48,12 +48,13 @@ export interface ActionLogger {
     warn: ActionLoggerFunction;
     error: ActionLoggerFunction;
 }
-export declare type ActionContext<TConfigVars extends ConfigVarResultCollection, THasConfigVars extends boolean = false> = {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection> = {
     logger: ActionLogger;
     instanceState: Record<string, unknown>;
     crossFlowState: Record<string, unknown>;
     executionState: Record<string, unknown>;
     integrationState: Record<string, unknown>;
+    configVars: TConfigVars;
     stepId: string;
     executionId: string;
     webhookUrls: Record<string, string>;
@@ -65,9 +66,7 @@ export declare type ActionContext<TConfigVars extends ConfigVarResultCollection,
     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>;
@@ -112,9 +111,9 @@ interface TriggerBranchingResult extends TriggerBaseResult {
     branch: string;
 }
 export declare type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
-export declare type TriggerPerformFunction = (context: ActionContext<any>, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
+export declare type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
 export declare type TriggerEventFunctionResult = TriggerEventFunctionReturn | void;
-export declare type TriggerEventFunction = (context: ActionContext<any>, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
+export declare type TriggerEventFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
 export interface Trigger {
     key: string;
     display: DisplayDefinition & {
@@ -137,8 +136,9 @@ export interface Trigger {
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
 }
-export interface DataSourceContext {
+export interface DataSourceContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection> {
     logger: ActionLogger;
+    configVars: TConfigVars;
     customer: CustomerAttributes;
     instance: InstanceAttributes;
     user: UserAttributes;
@@ -214,7 +214,7 @@ interface ServerPerformBranchingDataReturn extends ServerPerformDataReturn {
     branch: string;
 }
 export declare type ActionPerformReturn = ServerPerformDataStructureReturn | ServerPerformBranchingDataStructureReturn | ServerPerformDataReturn | ServerPerformBranchingDataReturn | undefined;
-export declare type ActionPerformFunction = (context: ActionContext<any>, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
+export declare type ActionPerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
 interface InputFieldChoice {
     label: string;
     value: string;

package/dist/serverTypes/integration.d.ts

@@ -0,0 +1,60 @@
+export declare const DefinitionVersion = 7;
+export interface ComponentReference {
+    key: string;
+    version: number | "LATEST";
+    isPublic: boolean;
+}
+export declare type Input = {
+    name?: string;
+    type: "value" | "reference" | "configVar" | "template";
+    value: string;
+    meta?: Record<string, unknown>;
+} | {
+    name?: string;
+    type: "complex";
+    value: string | Input;
+    meta?: Record<string, unknown>;
+};
+export interface ConnectionRequiredConfigVariable {
+    key: string;
+    stableKey: string;
+    description?: string;
+    orgOnly?: boolean;
+    dataType: "connection";
+    connection: {
+        component: ComponentReference;
+        key: string;
+    };
+    inputs?: Record<string, Input>;
+    meta?: Record<string, unknown>;
+}
+export interface DefaultRequiredConfigVariable {
+    key: string;
+    stableKey: string;
+    defaultValue?: string;
+    dataType: "string" | "date" | "timestamp" | "picklist" | "schedule" | "code" | "boolean" | "number" | "objectSelection" | "objectFieldMap" | "jsonForm";
+    pickList?: string[];
+    scheduleType?: "none" | "custom" | "minute" | "hour" | "day" | "week";
+    timeZone?: string;
+    codeLanguage?: "json" | "xml" | "html";
+    description?: string;
+    orgOnly?: boolean;
+    collectionType?: "valuelist" | "keyvaluelist";
+    dataSource?: {
+        component: ComponentReference;
+        key: string;
+    };
+    inputs?: Record<string, Input>;
+    meta?: Record<string, unknown>;
+}
+export declare type RequiredConfigVariable = DefaultRequiredConfigVariable | ConnectionRequiredConfigVariable;
+export interface ConfigPage {
+    name: string;
+    tagline?: string;
+    userLevelConfigured?: boolean;
+    elements: ConfigPageElement[];
+}
+export interface ConfigPageElement {
+    type: "configVar" | "htmlElement" | "jsonForm";
+    value: string;
+}

package/dist/serverTypes/integration.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionVersion = void 0;
+exports.DefinitionVersion = 7;

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, Flow, ConfigVarResultCollection, ConfigVarCollection, ConfigVarDefinitionsToResults } from "./types";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow, ConfigVarResultCollection, ConfigPages } 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, 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 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>> | undefined) => Promise<InvokeReturn<TReturn>>;
 export declare const defaultTriggerPayload: () => TriggerPayload;
 /**
  * Invokes specified TriggerDefinition perform function using supplied params
@@ -33,13 +33,13 @@ 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, 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>>;
+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>> | 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 {
+export declare const invokeDataSource: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TDataSourceType extends keyof {
     string: string;
     date: string;
     timestamp: string;
@@ -48,38 +48,40 @@ export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType
         value: string;
     };
     code: string;
-    credential: unknown;
     boolean: boolean;
     number: number;
-    connection: import("./types").Connection;
     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>>;
+}>({ perform }: DataSourceDefinition<TInputs, TConfigVars, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext<TConfigVars>> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+declare type TestConnectionValue = Pick<ConnectionValue, "fields" | "context" | "token">;
+declare type TestConfigVarValues = Record<string, string | TestConnectionValue>;
+declare type ToTestValues<TConfigVars extends ConfigVarResultCollection> = {
+    [K in keyof TConfigVars]: TConfigVars[K] extends ConnectionDefinition ? TestConnectionValue : string;
+};
 /**
  * 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 const invokeFlow: <TConfigPages extends ConfigPages, TConfigVars extends ConfigVarResultCollection = import("./types/utils").Prettify<{ [Key in keyof (TConfigPages extends ConfigPages ? import("./types/utils").UnionToIntersection<import("./types/utils").ValueOf<TConfigPages>["elements"]> : never)]: import("./types").ElementToRuntimeType<(TConfigPages extends ConfigPages ? import("./types/utils").UnionToIntersection<import("./types/utils").ValueOf<TConfigPages>["elements"]> : never)[Key]>; }>, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>>(flow: Flow<TConfigPages, import("./types").TriggerPayload>, configVars: TConfigVarValues, context?: Partial<ActionContext<TConfigVars>> | 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<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>;
+    dataSource<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<DataSourceContext<TConfigVars>>): Promise<DataSourceResult>;
 }
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
     loggerMock: () => ActionLogger;
-    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>>;
+    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>> | 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>> | 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 {
+    invokeDataSource: <TInputs_2 extends Inputs, TConfigVars_2 extends ConfigVarResultCollection, TDataSourceType extends keyof {
         string: string;
         date: string;
         timestamp: string;
@@ -88,13 +90,11 @@ declare const _default: {
             value: string;
         };
         code: string;
-        credential: unknown;
         boolean: boolean;
         number: number;
-        connection: import("./types").Connection;
         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>>;
+    }>({ perform }: DataSourceDefinition<TInputs_2, TConfigVars_2, TDataSourceType>, params: ActionInputParameters<TInputs_2>, context?: Partial<DataSourceContext<TConfigVars_2>> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 };
 export default _default;

package/dist/testing.js

@@ -39,7 +39,7 @@ const loggerMock = () => ({
 });
 exports.loggerMock = loggerMock;
 const createActionContext = (context) => {
-    return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
+    return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, configVars: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
             "Flow 1": "https://example.com",
         }, webhookApiKeys: {
             "Flow 1": ["example-123", "example-456"],
@@ -65,6 +65,21 @@ const createActionContext = (context) => {
             name: "Flow 1",
         }, startedAt: new Date().toISOString() }, context);
 };
+const createDataSourceContext = (context) => {
+    return Object.assign({ logger: (0, exports.loggerMock)(), configVars: {}, customer: {
+            id: "customerId",
+            name: "Customer 1",
+            externalId: "1234",
+        }, instance: {
+            id: "instanceId",
+            name: "Instance 1",
+        }, user: {
+            id: "userId",
+            email: "example@email.com",
+            externalId: "1234",
+            name: "Example",
+        } }, context);
+};
 /**
  * Invokes specified ActionDefinition perform function using supplied params
  * and optional context. Accepts a generic type matching ActionPerformReturn as a convenience
@@ -151,41 +166,33 @@ 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",
-    },
-    user: {
-        id: "userId",
-        email: "example@email.com",
-        externalId: "1234",
-        name: "Example",
-    },
-};
 /**
  * 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 realizedContext = createDataSourceContext(context);
     const result = yield perform(realizedContext, params);
     return result;
 });
 exports.invokeDataSource = invokeDataSource;
+const createConfigVars = (values) => {
+    return Object.entries(values).reduce((result, [key, value]) => {
+        // Connection
+        if (typeof value === "object" && "fields" in value) {
+            return Object.assign(Object.assign({}, result), { [key]: Object.assign(Object.assign({}, value), { key, configVarKey: "" }) });
+        }
+        return Object.assign(Object.assign({}, result), { [key]: value });
+    }, {});
+};
 /**
  * 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.
  */
-const invokeFlow = (flow, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = createActionContext(context);
+const invokeFlow = (flow, configVars, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedConfigVars = createConfigVars(configVars);
+    const realizedContext = createActionContext(Object.assign(Object.assign({}, context), { configVars: realizedConfigVars }));
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const params = {
         onTrigger: { results: null },
@@ -205,9 +212,6 @@ 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);
@@ -253,7 +257,7 @@ class ComponentTestHarness {
     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));
+            return dataSource.perform(createDataSourceContext(context), this.buildParams(dataSource.inputs, params));
         });
     }
 }

package/dist/types/ActionDefinition.d.ts

@@ -7,7 +7,7 @@ export interface ActionDefinition<TInputs extends Inputs = Inputs, TConfigVars e
     /** Defines how the Action is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Action is invoked. */
-    perform: ActionPerformFunction<TInputs, TConfigVars, false, TAllowsBranching, TReturn>;
+    perform: ActionPerformFunction<TInputs, TConfigVars, 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.*/

package/dist/types/ActionPerformFunction.d.ts

@@ -1,8 +1,8 @@
 import { Inputs, ConfigVarResultCollection, ActionPerformReturn, ActionInputParameters, ActionLogger, InstanceAttributes, CustomerAttributes, UserAttributes, IntegrationAttributes, FlowAttributes } from ".";
 /** Definition of the function to perform when an Action is invoked. */
-export declare type ActionPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, THasConfigVars extends boolean, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars, THasConfigVars>, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
+export declare type ActionPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars>, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
 /** Context provided to perform method containing helpers and contextual data */
-export declare type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, THasConfigVars extends boolean = false> = {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection> = {
     /** Logger for permanent logging; console calls are also captured */
     logger: ActionLogger;
     /** A a flow-specific key/value store that may be used to store small amounts of data that is persisted between Instance executions */
@@ -13,6 +13,8 @@ export declare type ActionContext<TConfigVars extends ConfigVarResultCollection
     executionState: Record<string, unknown>;
     /** A key/value store that is shared between all flows of an Instance for any version of an Integration that may be used to store small amounts of data that is persisted between Instance executions */
     integrationState: Record<string, unknown>;
+    /** Key/value collection of config variables of the integration. */
+    configVars: TConfigVars;
     /** A unique id that corresponds to the step on the Integration */
     stepId: string;
     /** A unique id that corresponds to the specific execution of the Integration */
@@ -35,7 +37,4 @@ export declare type ActionContext<TConfigVars extends ConfigVarResultCollection
     flow: FlowAttributes;
     /** The time in UTC that execution started. */
     startedAt: string;
-} & (THasConfigVars extends true ? {
-    /** Key/value collection of config variables of the integration. */
-    configVars: TConfigVars;
-} : Record<string, never>);
+};

package/dist/types/ComponentDefinition.d.ts

@@ -17,7 +17,7 @@ export declare type ComponentDefinition<TPublic extends boolean, TKey extends st
     /** Specifies the supported Triggers of this Component. */
     triggers?: Record<string, TriggerDefinition<any, any, boolean, any>>;
     /** Specifies the supported Data Sources of this Component. */
-    dataSources?: Record<string, DataSourceDefinition<any, any>>;
+    dataSources?: Record<string, DataSourceDefinition<any, any, any>>;
     /** Specifies the supported Connections of this Component. */
     connections?: ConnectionDefinition[];
     /** Hooks */

package/dist/types/DataSourceDefinition.d.ts

@@ -1,13 +1,13 @@
-import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceType } from ".";
+import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceType, ConfigVarResultCollection } 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> {
+export interface DataSourceDefinition<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, 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>;
+    perform: DataSourcePerformFunction<TInputs, TConfigVars, 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. */