@prismatic-io/spectral 8.1.6 → 9.0.0-rc.1

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, DataSourceDefinition, IntegrationDefinition, Flow, ConfigPage, StandardConfigVar, ConnectionConfigVar, ConfigVarResultCollection, TriggerPayload, DataSourceConfigVar, ConfigPages, OnPremConnectionDefinition, ScheduleConfigVar, ComponentSelector } from "./types";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition, IntegrationDefinition, Flow, ConfigPage, StandardConfigVar, ConnectionConfigVar, ConfigVarResultCollection, TriggerPayload, DataSourceConfigVar, OnPremConnectionDefinition, ScheduleConfigVar, ComponentManifest } from "./types";
 import { convertComponent } from "./serverTypes/convert";
 import { convertIntegration } from "./serverTypes/convertIntegration";
 /**
@@ -14,28 +14,21 @@ import { convertIntegration } from "./serverTypes/convertIntegration";
  * @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: <T extends IntegrationDefinition<any, any> = IntegrationDefinition<any, any>>(definition: T) => ReturnType<typeof convertIntegration>;
+export declare const integration: <T extends IntegrationDefinition = IntegrationDefinition>(definition: T) => 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: <TConfigPages extends ConfigPages<any> = ConfigPages<any>, TComponents extends ComponentSelector<any> = ComponentSelector<any>, TTriggerPayload extends TriggerPayload = TriggerPayload, T extends Flow<TConfigPages, TComponents, TTriggerPayload> = Flow<TConfigPages, TComponents, TTriggerPayload>>(definition: T) => T;
+export declare const flow: <TTriggerPayload extends TriggerPayload = TriggerPayload, T extends Flow<TTriggerPayload> = Flow<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<any> = ConfigPage<any>>(definition: T) => T;
-/**
- * @returns Helper utility to create component references.
- */
-export declare const reference: <TComponents extends ComponentSelector<any>>() => {
-    connection: <T extends ConnectionConfigVar<TComponents>>(definition: T) => T;
-    dataSource: <T_1 extends DataSourceConfigVar<TComponents>>(definition: T_1) => T_1;
-};
+export declare const configPage: <T extends ConfigPage = ConfigPage>(definition: T) => T;
 /**
  * For information on writing Code Native Integrations, see
  * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
@@ -49,14 +42,19 @@ export declare const configVar: <T extends StandardConfigVar | ScheduleConfigVar
  * @param definition A Data Source Config Var type object.
  * @returns This function returns a data source config var object that has the shape the Prismatic API expects.
  */
-export declare const dataSourceConfigVar: <T extends DataSourceConfigVar<any> = DataSourceConfigVar<any>>(definition: T) => T;
+export declare const dataSourceConfigVar: <TDataSourceConfigVar extends DataSourceConfigVar>(definition: TDataSourceConfigVar) => TDataSourceConfigVar;
 /**
  * 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<any> = ConnectionConfigVar<any>>(definition: T) => T;
+export declare const connectionConfigVar: <T extends ConnectionConfigVar = ConnectionConfigVar>(definition: T) => T;
+/**
+ * @param definition A Component Manifest type object.
+ * @returns This function returns a component manifest object that has the shape the Prismatic API expects.
+ */
+export declare const componentManifest: <T extends ComponentManifest>(definition: T) => T;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using
@@ -75,7 +73,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, TConfigVar extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TConfigVar, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, TConfigVar, TAllowsBranching, TReturn>;
+export declare const action: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>;
 /**
  * This function creates a trigger object that can be referenced
  * by a custom component. It helps ensure that the shape of the
@@ -85,7 +83,7 @@ export declare const action: <TInputs extends Inputs, TConfigVar extends ConfigV
  * @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, TConfigVar extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>>(definition: TriggerDefinition<TInputs, TConfigVar, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TConfigVar, TAllowsBranching, TResult>;
+export declare const trigger: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>>(definition: TriggerDefinition<TInputs, TConfigVars, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TConfigVars, 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
@@ -139,6 +137,7 @@ export declare const onPremConnection: <T extends OnPremConnectionDefinition>(de
  * @returns This functions validates the shape of the `definition` object provided and returns the same connection object.
  */
 export declare const oauth2Connection: <T extends OAuth2ConnectionDefinition>(definition: T) => T;
+export declare const componentManifests: <T extends Record<string, ComponentManifest>>(definition: T) => T;
 export { default as util } from "./util";
 export * from "./types";
 export { default as testing } from "./testing";

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.onPremConnection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = exports.connectionConfigVar = exports.dataSourceConfigVar = exports.configVar = exports.reference = exports.configPage = exports.flow = exports.integration = void 0;
+exports.testing = exports.util = exports.componentManifests = exports.oauth2Connection = exports.onPremConnection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = exports.componentManifest = exports.connectionConfigVar = exports.dataSourceConfigVar = exports.configVar = exports.configPage = exports.flow = exports.integration = void 0;
 const convert_1 = require("./serverTypes/convert");
 const convertIntegration_1 = require("./serverTypes/convertIntegration");
 /**
@@ -58,14 +58,6 @@ exports.flow = flow;
  */
 const configPage = (definition) => definition;
 exports.configPage = configPage;
-/**
- * @returns Helper utility to create component references.
- */
-const reference = () => ({
-    connection: (definition) => definition,
-    dataSource: (definition) => definition,
-});
-exports.reference = reference;
 /**
  * For information on writing Code Native Integrations, see
  * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
@@ -90,6 +82,12 @@ exports.dataSourceConfigVar = dataSourceConfigVar;
  */
 const connectionConfigVar = (definition) => definition;
 exports.connectionConfigVar = connectionConfigVar;
+/**
+ * @param definition A Component Manifest type object.
+ * @returns This function returns a component manifest object that has the shape the Prismatic API expects.
+ */
+const componentManifest = (definition) => definition;
+exports.componentManifest = componentManifest;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using
@@ -166,6 +164,8 @@ exports.onPremConnection = onPremConnection;
  */
 const oauth2Connection = (definition) => definition;
 exports.oauth2Connection = oauth2Connection;
+const componentManifests = (definition) => definition;
+exports.componentManifests = componentManifests;
 var util_1 = require("./util");
 Object.defineProperty(exports, "util", { enumerable: true, get: function () { return __importDefault(util_1).default; } });
 __exportStar(require("./types"), exports);

package/dist/serverTypes/convertIntegration.d.ts

@@ -1,3 +1,3 @@
-import { IntegrationDefinition, ConfigPages, ComponentSelector } from "../types";
+import { IntegrationDefinition } from "../types";
 import { Component as ServerComponent } from ".";
-export declare const convertIntegration: (definition: IntegrationDefinition<ConfigPages<any>, ComponentSelector<any>>) => ServerComponent;
+export declare const convertIntegration: (definition: IntegrationDefinition) => ServerComponent;

package/dist/serverTypes/convertIntegration.js

@@ -1,10 +1,20 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertIntegration = void 0;
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 const yaml_1 = __importDefault(require("yaml"));
 const uuid_1 = require("uuid");
 const lodash_1 = require("lodash");
@@ -34,7 +44,7 @@ const convertConfigPages = (pages) => {
         })),
     }));
 };
-const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, endpointType, triggerPreprocessFlowConfig, flows, configPages, }, referenceKey, configVars) => {
+const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, endpointType, triggerPreprocessFlowConfig, flows, configPages, componentRegistry = {}, }, 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.
@@ -68,32 +78,38 @@ const codeNativeIntegrationYaml = ({ name, description, category, documentation,
         documentation,
         version,
         labels,
-        requiredConfigVars: Object.entries(configVars || {}).map(([key, configVar]) => convertConfigVar(key, configVar, referenceKey)),
+        requiredConfigVars: Object.entries(configVars || {}).map(([key, configVar]) => convertConfigVar(key, configVar, referenceKey, componentRegistry)),
         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)),
+        flows: flows.map((flow) => convertFlow(flow, componentRegistry, referenceKey)),
         configPages: convertConfigPages(configPages !== null && configPages !== void 0 ? configPages : {}),
     };
     return yaml_1.default.stringify(result);
 };
-const convertComponentReference = ({ key, component: componentRef, values, }) => {
-    const component = typeof componentRef === "string"
-        ? {
-            key: componentRef,
-            version: "LATEST",
-            isPublic: true,
-        }
-        : {
-            key: componentRef.key,
-            version: "LATEST",
-            isPublic: componentRef.isPublic,
-        };
-    const inputs = Object.entries(values !== null && values !== void 0 ? values : {}).reduce((result, [key, value]) => {
+const convertComponentReference = (componentReference, componentRegistry) => {
+    var _a, _b, _c;
+    const ref = {
+        component: {
+            key: componentReference.component,
+            signature: (_b = (_a = componentRegistry[componentReference.component]) === null || _a === void 0 ? void 0 : _a.signature) !== null && _b !== void 0 ? _b : "",
+            isPublic: componentReference.isPublic,
+        },
+        key: componentReference.key,
+    };
+    const inputs = Object.entries((_c = componentReference.values) !== null && _c !== void 0 ? _c : {}).reduce((result, [key, value]) => {
         if ("value" in value) {
-            return Object.assign(Object.assign({}, result), { [key]: { type: "value", value: value.value } });
+            const type = value.value instanceof Object ? "complex" : "value";
+            const valueExpr = value.value instanceof Object && !Array.isArray(value.value)
+                ? Object.entries(value.value).map(([k, v]) => ({
+                    name: { type: "value", value: k },
+                    type: "value",
+                    value: v,
+                }))
+                : value.value;
+            return Object.assign(Object.assign({}, result), { [key]: { type: type, value: valueExpr } });
         }
         if ("configVar" in value) {
             return Object.assign(Object.assign({}, result), { [key]: { type: "configVar", value: value.configVar } });
@@ -101,12 +117,28 @@ const convertComponentReference = ({ key, component: componentRef, values, }) =>
         return result;
     }, {});
     return {
-        ref: { key, component },
+        ref,
         inputs,
     };
 };
+const convertComponentRegistry = (componentRegistry) => Object.values(componentRegistry).map(({ key, public: isPublic, signature }) => ({
+    key,
+    signature: signature !== null && signature !== void 0 ? signature : "",
+    isPublic,
+}));
+/**
+ * Create a reference to the private component built as part of this CNI.
+ *
+ * References to this component always use `version: "LATEST", isPublic: false`
+ * because they automatically publish alongside the corresponding CNI yml.
+ * */
+const codeNativeIntegrationComponentReference = (referenceKey) => ({
+    key: referenceKey,
+    version: "LATEST",
+    isPublic: false,
+});
 /** Converts a Flow into the structure necessary for YAML generation. */
-const convertFlow = (flow, referenceKey) => {
+const convertFlow = (flow, componentRegistry, referenceKey) => {
     var _a;
     const result = Object.assign({}, flow);
     delete result.onTrigger;
@@ -126,15 +158,11 @@ const convertFlow = (flow, referenceKey) => {
     if (typeof flow.onTrigger === "function") {
         triggerStep.action = {
             key: flowFunctionKey(flow.name, "onTrigger"),
-            component: {
-                key: referenceKey,
-                version: "LATEST",
-                isPublic: false,
-            },
+            component: codeNativeIntegrationComponentReference(referenceKey),
         };
     }
     else if ((0, types_1.isComponentReference)(flow.onTrigger)) {
-        const { ref, inputs } = convertComponentReference(flow.onTrigger);
+        const { ref, inputs } = convertComponentReference(flow.onTrigger, componentRegistry);
         triggerStep.action = ref;
         triggerStep.inputs = inputs;
     }
@@ -143,7 +171,14 @@ const convertFlow = (flow, referenceKey) => {
         const key = hasSchedule ? "schedule" : "webhook";
         triggerStep.action = {
             key,
-            component: { key: `${key}-triggers`, version: "LATEST", isPublic: true },
+            component: {
+                key: `${key}-triggers`,
+                /**
+                 * TODO: Add support for specific versions of platform triggers
+                 */
+                version: "LATEST",
+                isPublic: true,
+            },
         };
     }
     if ("schedule" in flow && typeof flow.schedule === "object") {
@@ -161,7 +196,7 @@ const convertFlow = (flow, referenceKey) => {
     const actionStep = {
         action: {
             key: flowFunctionKey(flow.name, "onExecution"),
-            component: { key: referenceKey, version: "LATEST", isPublic: false },
+            component: codeNativeIntegrationComponentReference(referenceKey),
         },
         name: "On Execution",
         stableKey: `${flow.stableKey}-onExecution`,
@@ -169,32 +204,32 @@ const convertFlow = (flow, referenceKey) => {
         errorConfig: "errorConfig" in flow ? Object.assign({}, flow.errorConfig) : undefined,
     };
     result.steps = [triggerStep, actionStep];
+    result.supplementalComponents = convertComponentRegistry(componentRegistry);
     return result;
 };
 /** Converts a Config Var into the structure necessary for YAML generation. */
-const convertConfigVar = (key, configVar, referenceKey) => {
+const convertConfigVar = (key, configVar, referenceKey, componentRegistry) => {
     const meta = (0, lodash_1.pick)(configVar, [
         "visibleToCustomerDeployer",
         "visibleToOrgDeployer",
     ]);
     if ((0, types_1.isConnectionDefinitionConfigVar)(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),
+                component: codeNativeIntegrationComponentReference(referenceKey),
             }, inputs: Object.entries(configVar.inputs).reduce((result, [key, input]) => {
                 if (input.shown === false) {
                     return result;
                 }
-                const value = input.default
-                    ? input.default
-                    : input.collection
-                        ? []
-                        : "";
-                return Object.assign(Object.assign({}, result), { [key]: { type: "value", value } });
+                const defaultValue = input.collection ? [] : "";
+                return Object.assign(Object.assign({}, result), { [key]: {
+                        type: input.collection ? "complex" : "value",
+                        value: input.default || defaultValue,
+                    } });
             }, {}), meta });
     }
     if ((0, types_1.isConnectionReferenceConfigVar)(configVar)) {
-        const { ref, inputs } = convertComponentReference(configVar.connection);
+        const { ref, inputs } = convertComponentReference(configVar.connection, componentRegistry);
         return Object.assign(Object.assign({}, (0, lodash_1.pick)(configVar, ["stableKey", "description", "orgOnly"])), { key, dataType: "connection", connection: Object.assign(Object.assign({}, ref), { template: configVar.connection.template }), inputs });
     }
     const result = (0, lodash_1.assign)({ meta, key }, (0, lodash_1.pick)(configVar, [
@@ -215,11 +250,11 @@ const convertConfigVar = (key, configVar, referenceKey) => {
         result.dataType = configVar.dataSourceType;
         result.dataSource = {
             key: (0, lodash_1.camelCase)(key),
-            component: { key: referenceKey, version: "LATEST", isPublic: false },
+            component: codeNativeIntegrationComponentReference(referenceKey),
         };
     }
     if ((0, types_1.isDataSourceReferenceConfigVar)(configVar)) {
-        const { ref, inputs } = convertComponentReference(configVar.dataSource);
+        const { ref, inputs } = convertComponentReference(configVar.dataSource, componentRegistry);
         result.dataType = configVar.dataSourceType;
         result.dataSource = ref;
         result.inputs = inputs;
@@ -244,9 +279,28 @@ const flowFunctionKey = (flowName, functionName) => {
         .join("");
     return `${flowKey}_${functionName}`;
 };
+const convertOnExecution = (onExecution, componentRegistry) => (context, params) => {
+    // @ts-expect-error _components isn't part of the public API
+    const { _components } = context, remainingContext = __rest(context, ["_components"]);
+    const invoke = _components
+        .invoke;
+    const componentMethods = Object.entries(componentRegistry).reduce((acc, [componentKey, { actions, public: isPublic, signature }]) => {
+        return Object.assign(Object.assign({}, acc), { [componentKey]: Object.keys(actions).reduce((acc, actionKey) => (Object.assign(Object.assign({}, acc), { [actionKey]: (values) => {
+                    return invoke({
+                        component: {
+                            key: componentKey,
+                            signature: signature !== null && signature !== void 0 ? signature : "",
+                            isPublic,
+                        },
+                        key: actionKey,
+                    }, context, values);
+                } })), {}) });
+    }, {});
+    return onExecution(Object.assign(Object.assign({}, remainingContext), { components: componentMethods }), params);
+};
 /** Creates the structure necessary to import a Component as part of a
  *  Code Native integration. */
-const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], }, referenceKey, configVars) => {
+const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], componentRegistry = {}, }, referenceKey, configVars) => {
     const convertedActions = flows.reduce((result, { name, onExecution }) => {
         const key = flowFunctionKey(name, "onExecution");
         return Object.assign(Object.assign({}, result), { [key]: {
@@ -255,7 +309,7 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
                     label: `${name} - onExecution`,
                     description: "The function that will be executed by the flow.",
                 },
-                perform: onExecution,
+                perform: convertOnExecution(onExecution, componentRegistry),
                 inputs: [],
             } });
     }, {});
@@ -271,9 +325,9 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
                     description: "The function that will be executed by the flow to return an HTTP response.",
                 },
                 perform: onTrigger,
-                onInstanceDeploy,
+                onInstanceDeploy: onInstanceDeploy,
                 hasOnInstanceDeploy: !!onInstanceDeploy,
-                onInstanceDelete,
+                onInstanceDelete: onInstanceDeploy,
                 hasOnInstanceDelete: !!onInstanceDelete,
                 inputs: [],
                 scheduleSupport: "valid",

package/dist/serverTypes/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -48,13 +48,14 @@ export interface ActionLogger {
     warn: ActionLoggerFunction;
     error: ActionLoggerFunction;
 }
-export declare type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection> = {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>> = {
     logger: ActionLogger;
     instanceState: Record<string, unknown>;
     crossFlowState: Record<string, unknown>;
     executionState: Record<string, unknown>;
     integrationState: Record<string, unknown>;
     configVars: TConfigVars;
+    components: TComponentActions;
     stepId: string;
     executionId: string;
     webhookUrls: Record<string, string>;

package/dist/serverTypes/integration.d.ts

@@ -1,5 +1,5 @@
 export declare const DefinitionVersion = 7;
-export interface ComponentReference {
+export declare type ComponentReference = {
     component: {
         key: string;
         version: number | "LATEST";
@@ -7,14 +7,22 @@ export interface ComponentReference {
     };
     key: string;
     template?: string;
-}
+} | {
+    component: {
+        key: string;
+        signature: string;
+        isPublic: boolean;
+    };
+    key: string;
+    template?: string;
+};
 export declare type Input = {
-    name?: string;
+    name?: string | Input;
     type: "value" | "reference" | "configVar" | "template";
     value: string;
     meta?: Record<string, unknown>;
 } | {
-    name?: string;
+    name?: string | Input;
     type: "complex";
     value: string | Input;
     meta?: Record<string, unknown>;

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, ConfigPages, ComponentSelector } from "./types";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow, ConfigVarResultCollection } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>, tokenValues?: Record<string, unknown> | undefined) => ConnectionValue;
 export declare const defaultConnectionValueEnvironmentVariable = "PRISMATIC_CONNECTION_VALUE";
 export declare const connectionValue: (envVarKey?: string) => ConnectionValue;
@@ -27,7 +27,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>> | 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, Record<string, Record<string, import("./types").ComponentManifestAction>>>> | undefined) => Promise<InvokeReturn<TReturn>>;
 export declare const defaultTriggerPayload: () => TriggerPayload;
 /**
  * Invokes specified TriggerDefinition perform function using supplied params
@@ -35,7 +35,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, 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>>;
+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, Record<string, Record<string, import("./types").ComponentManifestAction>>>> | 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
@@ -65,9 +65,9 @@ declare type ToTestValues<TConfigVars extends ConfigVarResultCollection> = {
  * 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: <TConfigPages extends ConfigPages<any>, TConfigVars extends ConfigVarResultCollection = import("./types/utils").Prettify<{ [Key in keyof import("./types").GetElements<TConfigPages> as Key extends string ? Key : never]: import("./types").ElementToRuntimeType<import("./types").GetElements<TConfigPages>[Key]>; }>, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>>(flow: Flow<TConfigPages, ComponentSelector<any>, import("./types").TriggerPayload>, { configVars, context, payload, }?: {
+export declare const invokeFlow: <TConfigVars extends import("./types/utils").Prettify<{} & {}> = import("./types/utils").Prettify<{} & {}>, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>>(flow: Flow, { configVars, context, payload, }?: {
     configVars?: TConfigVarValues | undefined;
-    context?: Partial<ActionContext<TConfigVars>> | undefined;
+    context?: Partial<ActionContext<TConfigVars, Record<string, Record<string, import("./types").ComponentManifestAction>>>> | undefined;
     payload?: Partial<TriggerPayload> | undefined;
 }) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
@@ -84,8 +84,8 @@ export declare class ComponentTestHarness<TComponent extends Component> {
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
     loggerMock: () => ActionLogger;
-    invoke: <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>>;
+    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, Record<string, Record<string, import("./types").ComponentManifestAction>>>> | 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, Record<string, Record<string, import("./types").ComponentManifestAction>>>> | 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, TConfigVars_2 extends ConfigVarResultCollection, TDataSourceType extends keyof {
         string: string;

package/dist/testing.js

@@ -49,7 +49,7 @@ const loggerMock = () => ({
 });
 exports.loggerMock = loggerMock;
 const createActionContext = (context) => {
-    return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, configVars: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
+    return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, configVars: {}, components: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
             "Flow 1": "https://example.com",
         }, webhookApiKeys: {
             "Flow 1": ["example-123", "example-456"],

package/dist/types/ActionDefinition.d.ts

@@ -1,4 +1,5 @@
 import { ActionDisplayDefinition, ActionPerformFunction, ActionPerformReturn, ConfigVarResultCollection, Inputs } from ".";
+import { ComponentManifestAction } from "./ComponentManifest";
 /**
  * ActionDefinition is the type of the object that is passed in to `action` function to
  * define a component action.
@@ -7,7 +8,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, TAllowsBranching, TReturn>;
+    perform: ActionPerformFunction<TInputs, TConfigVars, Record<string, Record<string, ComponentManifestAction>>, 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 ".";
+import { Inputs, ConfigVarResultCollection, ActionPerformReturn, ActionInputParameters, ActionLogger, InstanceAttributes, CustomerAttributes, UserAttributes, IntegrationAttributes, FlowAttributes, ComponentManifest } from ".";
 /** Definition of the function to perform when an Action is invoked. */
-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>;
+export declare type ActionPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]>, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars, TComponentActions>, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
 /** Context provided to perform method containing helpers and contextual data */
-export declare type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection> = {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>> = {
     /** 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 */
@@ -15,6 +15,8 @@ export declare type ActionContext<TConfigVars extends ConfigVarResultCollection
     integrationState: Record<string, unknown>;
     /** Key/value collection of config variables of the integration. */
     configVars: TConfigVars;
+    /** Available component actions registered in the `componentRegistry`. */
+    components: TComponentActions;
     /** 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 */

package/dist/types/ComponentManifest.d.ts

@@ -0,0 +1,13 @@
+export interface ComponentManifest {
+    key: string;
+    public: boolean;
+    signature: string | null;
+    actions: Record<string, ComponentManifestAction>;
+    triggers: Record<string, ComponentManifestTrigger>;
+    dataSources: Record<string, ComponentManifestDataSource>;
+    connections: Record<string, ComponentManifestConnection>;
+}
+export declare type ComponentManifestAction = (values: any) => Promise<unknown>;
+export declare type ComponentManifestTrigger = (values: any) => Promise<unknown>;
+export declare type ComponentManifestDataSource = (values: any) => Promise<unknown>;
+export declare type ComponentManifestConnection = (values: any) => Promise<unknown>;

package/dist/types/ComponentManifest.js

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

package/dist/types/DataSourceResult.d.ts

@@ -16,6 +16,7 @@ declare type DataSourceTypeMap = {
     jsonForm: JSONForm;
 };
 export declare type DataSourceType = keyof DataSourceTypeMap;
+export declare type CollectionDataSourceType = Exclude<DataSourceType, "objectSelection" | "objectFieldMap" | "jsonForm">;
 export declare type DataSourceResultType = DataSourceTypeMap[DataSourceType];
 /** Represents the result of a Data Source action. */
 export declare type DataSourceResult<TDataSourceType extends DataSourceType> = {