@prismatic-io/spectral 8.0.0-preview7 → 8.0.0-preview8

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 } from "./types";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition, IntegrationDefinition, Flow, ConfigPage, StandardConfigVar, ConnectionConfigVar, ConnectionRefConfigVar } from "./types";
 import { convertComponent, convertIntegration } from "./serverTypes/convert";
 /**
  * This function creates a Integration object that can be
@@ -28,6 +28,27 @@ export declare const flow: <T extends Flow>(definition: T) => T;
  * @returns This function returns a config page object that has the shape the Prismatic API expects.
  */
 export declare const configPage: <T extends ConfigPage>(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;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
+ * @param definition A Connection Reference Config Var type object.
+ * @returns This function returns a connection reference config var object that has the shape the Prismatic API expects.
+ */
+export declare const connectionRefConfigVar: <T extends ConnectionRefConfigVar>(definition: T) => T;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using

package/dist/index.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = exports.configPage = exports.flow = exports.integration = void 0;
+exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = exports.connectionRefConfigVar = 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
@@ -50,6 +50,30 @@ exports.flow = flow;
  */
 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;
+/**
+ * For information on writing Code Native Integrations, see
+ * https://prismatic.io/docs/code-native-integrations/#adding-config-vars.
+ * @param definition A Connection Reference Config Var type object.
+ * @returns This function returns a connection reference config var object that has the shape the Prismatic API expects.
+ */
+const connectionRefConfigVar = (definition) => definition;
+exports.connectionRefConfigVar = connectionRefConfigVar;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using

package/dist/serverTypes/convert.js

@@ -135,17 +135,22 @@ const codeNativeIntegrationYaml = ({ name, description, category, documentation,
 /** 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.action;
+    delete result.onInstanceDeploy;
+    delete result.onInstanceDelete;
+    delete result.onExecution;
     delete result.preprocessFlowConfig;
+    delete result.errorConfig;
     const triggerStep = {
-        name: "trigger",
+        name: `${flow.name} - onTrigger`,
+        description: "The function that will be executed by the flow to return an HTTP response.",
         isTrigger: true,
-        errorConfig: "errorConfig" in flow.trigger ? flow.trigger.errorConfig : undefined,
+        errorConfig: "errorConfig" in flow ? Object.assign({}, flow.errorConfig) : undefined,
     };
-    if ("perform" in flow.trigger) {
+    if ("onTrigger" in flow) {
         triggerStep.action = {
-            key: flowFunctionKey(flow.name, "trigger"),
+            key: flowFunctionKey(flow.name, "onTrigger"),
             component: { key: referenceKey, version: "LATEST", isPublic: false },
         };
     }
@@ -154,10 +159,9 @@ const convertFlow = (flow, referenceKey) => {
             key: flow.trigger.key,
             component: flow.trigger.component,
         };
-    }
-    if ("inputs" in flow.trigger) {
-        triggerStep.inputs = flow.trigger.inputs;
-        delete result.inputs;
+        if ("inputs" in flow.trigger) {
+            triggerStep.inputs = flow.trigger.inputs;
+        }
     }
     if ("schedule" in flow && typeof flow.schedule === "object") {
         triggerStep.schedule = {
@@ -176,34 +180,77 @@ const convertFlow = (flow, referenceKey) => {
     }
     const actionStep = {
         action: {
-            key: flowFunctionKey(flow.name, "action"),
+            key: flowFunctionKey(flow.name, "onExecution"),
             component: { key: referenceKey, version: "LATEST", isPublic: false },
         },
-        name: "action",
-        errorConfig: "errorConfig" in flow.action ? flow.action.errorConfig : undefined,
+        name: `${flow.name} - 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 = (configVar, referenceKey) => {
-    const result = Object.assign(Object.assign({}, configVar), { meta: {} });
+    // 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 result) {
-        result.meta.visibleToOrgDeployer = result.visibleToOrgDeployer;
-        delete result.visibleToOrgDeployer;
+    if ("visibleToOrgDeployer" in configVar) {
+        result.meta.visibleToOrgDeployer = configVar.visibleToOrgDeployer;
     }
-    if ("visibleToCustomerDeployer" in result) {
-        result.meta.visibleToCustomerDeployer = result.visibleToCustomerDeployer;
-        delete result.visibleToCustomerDeployer;
+    if ("visibleToCustomerDeployer" in configVar) {
+        result.meta.visibleToCustomerDeployer = configVar.visibleToCustomerDeployer;
     }
-    if ("connection" in result && typeof result.connection === "string") {
-        result.connection = {
-            key: result.connection,
-            component: { key: referenceKey, version: "LATEST", isPublic: false },
-        };
+    // Handle connections.
+    if ("label" in configVar || "component" in configVar) {
+        result.dataType = "connection";
+        if ("component" in configVar) {
+            // This is a reference to another Component's connection.
+            result.connection = {
+                key: configVar.key,
+                component: configVar.component,
+            };
+        }
+        else {
+            // 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.
+            result.inputs = Object.keys(configVar.inputs).reduce((result, key) => {
+                return Object.assign(Object.assign({}, result), { [key]: {
+                        type: types_1.SimpleInputValueType.Value,
+                        value: "",
+                    } });
+            }, {});
+        }
     }
+    // Handle data source references.
     if ("dataSource" in result && typeof result.dataSource === "string") {
+        // This is a reference to a data source we are creating.
         result.dataSource = {
             key: result.dataSource,
             component: { key: referenceKey, version: "LATEST", isPublic: false },
@@ -238,19 +285,50 @@ const flowFunctionKey = (flowName, functionName) => {
 };
 /** Creates the structure necessary to import a Component as part of a
  *  Code Native integration. */
-const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], dataSources = {}, connections = [], }, referenceKey) => {
-    const convertedActions = flows.reduce((result, { name, action }) => {
-        const actionKey = flowFunctionKey(name, "action");
-        return Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, Object.assign(Object.assign({}, action), { display: { label: "action", description: "" }, inputs: {} })) });
+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, { name, trigger }) => {
+    const convertedTriggers = flows.reduce((result, flow) => {
         // Filter out TriggerReferences.
-        if (typeof trigger !== "object" || !("perform" in trigger))
+        if ("trigger" in flow)
             return result;
-        const triggerKey = flowFunctionKey(name, "trigger");
-        return Object.assign(Object.assign({}, result), { [triggerKey]: convertTrigger(triggerKey, Object.assign(Object.assign({}, trigger), { display: { label: "trigger", description: "" }, inputs: {}, scheduleSupport: "valid", synchronousResponseSupport: "valid" })) });
+        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 = configVars.reduce((result, 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(connection)];
+    }, []);
     return {
         key: referenceKey,
         display: {
@@ -258,7 +336,7 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
             iconPath,
             description: description || name,
         },
-        connections: connections.map(convertConnection),
+        connections: convertedConnections,
         actions: convertedActions,
         triggers: convertedTriggers,
         dataSources: convertedDataSources,

package/dist/testing.d.ts

@@ -60,7 +60,7 @@ export declare const invokeDataSource: <TInputs extends Inputs, 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: ({ trigger, action }: Flow, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
+export declare const invokeFlow: (flow: Flow, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);

package/dist/testing.js

@@ -199,15 +199,15 @@ exports.invokeDataSource = invokeDataSource;
  * 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 = ({ trigger, action }, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
+const invokeFlow = (flow, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
     const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const params = {};
-    if (typeof trigger === "object" && "perform" in trigger) {
-        const triggerResult = yield trigger.perform(realizedContext, realizedPayload, params);
+    if ("onTrigger" in flow) {
+        const triggerResult = yield flow.onTrigger(realizedContext, realizedPayload, params);
         params.trigger = triggerResult;
     }
-    const result = yield action.perform(realizedContext, params);
+    const result = yield flow.onExecution(realizedContext, params);
     return {
         result,
         loggerMock: realizedContext.logger,

package/dist/types/IntegrationDefinition.d.ts

@@ -1,4 +1,4 @@
-import { DataSourceDefinition, ConnectionDefinition, ActionDefinition, ActionPerformReturn, TriggerDefinition, Inputs, TriggerResult, DataSourceType } from ".";
+import { DataSourceDefinition, ConnectionDefinition, ActionPerformFunction, ActionPerformReturn, TriggerEventFunction, TriggerPerformFunction, Inputs, TriggerResult, DataSourceType } from ".";
 /** Defines attributes of a Code-Native Integration. */
 export declare type IntegrationDefinition = {
     /** The unique name for this Integration. */
@@ -30,11 +30,9 @@ export declare type IntegrationDefinition = {
     configPages?: ConfigPage[];
     /** Specifies any Data Sources that are defined as part of this Integration. */
     dataSources?: Record<string, CodeNativeDataSource>;
-    /** Specifies any Connections that are defined as part of this Integration. */
-    connections?: ConnectionDefinition[];
 };
-/** Defines attributes of a Flow of a Code-Native Integration. */
-export declare type Flow = {
+/** Defines common attributes of a Flow of a Code-Native Integration. */
+declare type BaseFlow = {
     /** The unique name for this Flow. */
     name: string;
     /** Optional description for this Flow. */
@@ -51,23 +49,29 @@ export declare type Flow = {
     organizationApiKeys?: string[];
     /** Optional schedule configuration that defines the frequency with which this Flow will be automatically executed. */
     schedule?: FlowSchedule;
-    /** Specifies the trigger for this Flow. */
-    trigger: (CodeNativeTrigger | TriggerReference) & {
-        /** Optional error handling configuration. */
-        errorConfig?: StepErrorConfig;
-    };
-    /** Specifies the main function for this Flow. */
-    action: CodeNativeAction;
-};
-/** Defines attributes of a Data Source that is defined as part of a Code Native Integration. */
-export declare type CodeNativeDataSource = Pick<DataSourceDefinition<Inputs, DataSourceType>, "display" | "perform" | "dataSourceType" | "detailDataSource">;
-/** Defines attributes of a Trigger that is defined as part of a Code Native Integration. */
-export declare type CodeNativeTrigger = Pick<TriggerDefinition<Inputs, false, TriggerResult<false>>, "display" | "perform" | "onInstanceDeploy" | "onInstanceDelete">;
-/** Defines attributes of an CodeNativeAction, which is the main function that will be executed for a Flow of a Code Native Integration. */
-export declare type CodeNativeAction = Pick<ActionDefinition<Inputs, false, ActionPerformReturn<false, unknown>>, "display" | "perform"> & {
     /** Optional error handling configuration. */
     errorConfig?: StepErrorConfig;
+    /** Specifies the main function for this Flow */
+    onExecution: ActionPerformFunction<Inputs, false, ActionPerformReturn<false, unknown>>;
+};
+/** Defines attributes of a Flow that will have custom Trigger logic. */
+declare type CustomTriggerFlow = BaseFlow & {
+    /** Specifies the trigger function for this Flow, which returns a payload and optional HTTP response. */
+    onTrigger: TriggerPerformFunction<Inputs, false, TriggerResult<false>>;
+    /** Specifies the function to execute when an Instance of this Integration is deployed. */
+    onInstanceDeploy?: TriggerEventFunction<Inputs>;
+    /** Specifies the function to execute when an Instance of an Integration is deleted. */
+    onInstanceDelete?: TriggerEventFunction<Inputs>;
 };
+/** Defines attributes of a Flow that will use a Trigger from an existing Component. */
+declare type PrebuiltTriggerFlow = BaseFlow & {
+    /** Specifies the prebuilt Trigger that will run when this Flow executes. */
+    trigger: TriggerReference;
+};
+/** Defines attributes of a Flow of a Code-Native Integration. */
+export declare type Flow = CustomTriggerFlow | PrebuiltTriggerFlow;
+/** Defines attributes of a Data Source that is defined as part of a Code Native Integration. */
+export declare type CodeNativeDataSource = Pick<DataSourceDefinition<Inputs, DataSourceType>, "display" | "perform" | "dataSourceType" | "detailDataSource">;
 /** Defines attributes of a reference to an existing Trigger. */
 export declare type TriggerReference = {
     /** Attributes of the referenced Component. */
@@ -84,13 +88,6 @@ export declare type DataSourceReference = {
     /** The unique key that identifies the Data Source within the Component. */
     key: string;
 };
-/** Defines attributes of a reference to an existing Connection. */
-export declare type ConnectionReference = {
-    /** Attributes of the referenced Component. */
-    component: ComponentReference;
-    /** The unique key that identifies the Connection within the Component. */
-    key: string;
-};
 /** Defines attributes of a reference to a member of an existing Component. */
 export declare type ComponentReference = {
     /** The unique key that identifies the Component. */
@@ -116,7 +113,7 @@ declare type BaseConfigVar = {
     visibleToCustomerDeployer?: boolean;
 };
 /** Defines attributes of a standard Config Var. */
-declare type StandardConfigVar = BaseConfigVar & {
+export declare type StandardConfigVar = BaseConfigVar & {
     /** Optional default value for the Config Var. */
     defaultValue?: string;
     /** The data type of the Config Var. */
@@ -138,16 +135,12 @@ declare type StandardConfigVar = BaseConfigVar & {
     dataSource?: string | DataSourceReference;
 };
 /** Defines attributes of a Config Var that represents a Connection. */
-declare type ConnectionConfigVar = BaseConfigVar & {
-    dataType: "connection";
-    /** Optional value to specify the Data Source where the Config Var sources
-     *  its values. If it's a string then it's expected to be the key of a
-     *  Connection defined in the Code Native Integration. Otherwise it is
-     *  expected to be a reference to an existing Connection. */
-    connection: string | ConnectionReference;
+export declare type ConnectionConfigVar = Omit<BaseConfigVar, "description" | "inputs"> & ConnectionDefinition;
+export declare type ConnectionRefConfigVar = BaseConfigVar & {
+    /** Attributes of the referenced Component. */
+    component: ComponentReference;
 };
-/** Defines attributes of a Config Var whose value is configured as part of deploying an Instance of an Integration. */
-export declare type ConfigVar = StandardConfigVar | ConnectionConfigVar;
+export declare type ConfigVar = StandardConfigVar | ConnectionConfigVar | ConnectionRefConfigVar;
 /** Defines attributes of a Config Wizard Page used when deploying an Instance of an Integration. */
 export declare type ConfigPage = {
     /** The unique name for this Config Page. */

package/package.json

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