@prismatic-io/spectral 4.0.6 → 5.0.0-rc.0

package/README.md

@@ -14,22 +14,23 @@ Please see our [documentation](https://prismatic.io/docs/custom-components/writi
 
 ## What is Prismatic?
 
-Prismatic is the embedded integration platform for B2B software companies. It's the easiest way to build integrations and provide a first-class integration experience to your customers.
+Prismatic is the integration platform for B2B software companies. It's the quickest way to build integrations to the other apps your customers use and to add a native integration marketplace to your product.
 
-Prismatic reduces integration effort and empowers every role with exactly what they need, so you can spend less time on integrations and more time on core product innovation.
+Prismatic significantly reduces overall integration effort and enables non-dev teams to take on more of the integration workload, so that you can deliver integrations faster and spend more time on core product innovation.
 
 With Prismatic, you can:
 
-- Build reusable [integrations](https://prismatic.io/docs/integrations) in an intuitive low-code integration designer
-- Easily deploy customer-specific integration [instances](https://prismatic.io/docs/instances) with unique configurations and credentials
-- Run your integrations in a purpose-built environment
-- Provide better support with built-in [logging](https://prismatic.io/docs/logging) and [alerting](https://prismatic.io/docs/monitoring-and-alerting)
-- Embed a white-labeled customer integration portal with an [integration marketplace](https://prismatic.io/docs/integration-marketplace/) and customer self-service tools
-- Mold the platform to your product, industry, and the way you build software
+- Build reusable [integrations](https://prismatic.io/docs/integrations) in a low-code integration designer that's tailored for your product
+- Use [pre-built components](https://prismatic.io/docs/components/component-catalog) to handle most of your integrations' functionality, and write [custom components](https://prismatic.io/docs/custom-components/writing-custom-components) when needed
+- Quickly add an [integration marketplace](https://prismatic.io/docs/integration-marketplace) to your product so customers can explore, activate, and monitor integrations
+- Easily deploy customer-specific integration [instances](https://prismatic.io/docs/instances) with unique configurations and connections
+- Provide better support with tools like [logging](https://prismatic.io/docs/logging) and [alerting](https://prismatic.io/docs/monitoring-and-alerting)
+- Run your integrations in a purpose-built environment designed for security and scalability
+- Use powerful dev tools to mold the platform to your product, industry, and the way you build software
 
 ## Who uses Prismatic?
 
-Prismatic is for B2B (business-to-business) software companies, meaning software companies that provide applications used by businesses. It's a good fit for products/teams at any stage, including early stage SaaS, established SaaS, and legacy or on-prem systems.
+Prismatic is for B2B (business-to-business) software companies, meaning software companies that provide applications used by businesses. It's a good fit for products/teams ranging from early-stage and growing SaaS startups to large, established software companies looking to improve the way they do integrations.
 
 Many B2B software teams serve customers in niche vertical markets, and we designed Prismatic with that in mind. We provide powerful and flexible tools so you can build exactly the integrations your customers need, no matter who your customers are, no matter what systems you need to connect to, no matter how "non-standard" your integration scenario.
 

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+import { Connection } from ".";
+export declare class SpectralError extends Error {
+    isSpectralError: boolean;
+    constructor(message: string);
+}
+export declare class ConnectionError extends SpectralError {
+    connection: Connection;
+    constructor(connection: Connection, message: string);
+}
+export declare const isSpectralError: (payload: unknown) => payload is SpectralError;
+export declare const isConnectionError: (payload: unknown) => payload is ConnectionError;

package/dist/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConnectionError = exports.isSpectralError = exports.ConnectionError = exports.SpectralError = void 0;
+class SpectralError extends Error {
+    constructor(message) {
+        super(message);
+        this.isSpectralError = true;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.SpectralError = SpectralError;
+class ConnectionError extends SpectralError {
+    constructor(connection, message) {
+        super(message);
+        this.connection = connection;
+    }
+}
+exports.ConnectionError = ConnectionError;
+const isSpectralError = (payload) => Boolean(payload &&
+    typeof payload === "object" &&
+    "isSpectralError" in payload &&
+    payload.isSpectralError === true);
+exports.isSpectralError = isSpectralError;
+const isConnectionError = (payload) => exports.isSpectralError(payload) && "connection" in payload;
+exports.isConnectionError = isConnectionError;

package/dist/index.d.ts

@@ -7,20 +7,17 @@
  * Both component author-facing types and server types that
  * the Prismatic API expects are imported here.
  */
-import { ActionDefinition, InputFieldDefinition, ActionPerformReturn, Inputs, TriggerDefinition, TriggerResult } from "./types";
+import { ActionDefinition, InputFieldDefinition, ActionPerformReturn, ComponentDefinition, ConnectionFieldDefinition, Inputs, TriggerDefinition, TriggerResult } from "./types";
 import { Component } from "./types/server-types";
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using
  * this function to write custom components, see
  * https://prismatic.io/docs/custom-components/writing-custom-components/#exporting-a-component.
- * @param definition A ComponentDefinition type object, including display infromation, unique key, authorization information, and a set of actions the component implements.
+ * @param definition A ComponentDefinition type object, including display infromation, unique key, and a set of actions the component implements.
  * @returns This function returns a component object that has the shape the Prismatic API expects.
  */
-export declare const component: <T extends boolean>(definition: Omit<Component<T>, "actions" | "triggers"> & {
-    actions?: Record<string, ActionDefinition<any, boolean, ActionPerformReturn<boolean, any>>> | undefined;
-    triggers?: Record<string, TriggerDefinition<any, boolean, TriggerResult<boolean>>> | undefined;
-}) => Component<T>;
+export declare const component: <T extends boolean>(definition: ComponentDefinition<T>) => Component<T>;
 /**
  * This function creates an action object that can be referenced
  * by a custom component. It helps ensure that the shape of the
@@ -49,6 +46,16 @@ export declare const trigger: <T extends Inputs, AllowsBranching extends boolean
  * @returns This function validates the shape of the `definition` object provided, and returns the same input object.
  */
 export declare const input: <T extends InputFieldDefinition>(definition: T) => T;
+/**
+ * For information on writing custom component connections, see
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#adding-connections.
+ * @param definition A ConnectionfieldDefinition object that describes the type of a connection for a custom component action or trigger, and information on how it should be displayed in the Prismatic WebApp.
+ * @returns This functions validates the shape of the `definition` object provided and returns the same connection object.
+ */
+export declare const connection: <T extends Omit<ConnectionFieldDefinition, "type">>(definition: T) => T & {
+    type: "connection";
+};
 export { default as util } from "./util";
 export * from "./types";
 export { default as testing } from "./testing";
+export * from "./errors";

package/dist/index.js

@@ -18,7 +18,14 @@ 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.input = exports.trigger = exports.action = exports.component = void 0;
+exports.testing = exports.util = exports.connection = exports.input = exports.trigger = exports.action = exports.component = void 0;
+const convertInput = (key, input) => {
+    var _a;
+    if ("inputs" in input) {
+        return Object.assign(Object.assign({}, input), { key, inputs: Object.entries((_a = input.inputs) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => convertInput(key, value)) });
+    }
+    return Object.assign(Object.assign({}, input), { key });
+};
 /**
  * This is a helper function for component() to convert an
  * action defined in TypeScript into an action object that
@@ -29,9 +36,7 @@ exports.testing = exports.util = exports.input = exports.trigger = exports.actio
  */
 const convertAction = (actionKey, action) => {
     var _a;
-    const items = Object.entries((_a = action.inputs) !== null && _a !== void 0 ? _a : {});
-    const inputDefinitions = items.map(([key, value]) => (Object.assign({ key }, (typeof value === "object" ? value : {}))));
-    return Object.assign(Object.assign({}, action), { key: actionKey, inputs: inputDefinitions, perform: action.perform, examplePayload: action.examplePayload });
+    return (Object.assign(Object.assign({}, action), { key: actionKey, inputs: Object.entries((_a = action.inputs) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => convertInput(key, value)), perform: action.perform, examplePayload: action.examplePayload }));
 };
 /**
  * This is a helper function for component() to convert a
@@ -43,24 +48,29 @@ const convertAction = (actionKey, action) => {
  */
 const convertTrigger = (triggerKey, trigger) => {
     var _a;
-    const items = Object.entries((_a = trigger.inputs) !== null && _a !== void 0 ? _a : {});
-    const inputDefinitions = items.map(([key, value]) => (Object.assign({ key }, (typeof value === "object" ? value : {}))));
-    return Object.assign(Object.assign({}, trigger), { key: triggerKey, inputs: inputDefinitions, perform: trigger.perform, examplePayload: trigger.examplePayload || undefined });
+    return (Object.assign(Object.assign({}, trigger), { key: triggerKey, inputs: Object.entries((_a = trigger.inputs) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => convertInput(key, value)), perform: trigger.perform, examplePayload: trigger.examplePayload || undefined }));
+};
+const convertConnection = (connectionKey, connection) => {
+    var _a;
+    return (Object.assign(Object.assign({}, connection), { key: connectionKey, inputs: Object.entries((_a = connection.inputs) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => convertInput(key, value)) }));
 };
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using
  * this function to write custom components, see
  * https://prismatic.io/docs/custom-components/writing-custom-components/#exporting-a-component.
- * @param definition A ComponentDefinition type object, including display infromation, unique key, authorization information, and a set of actions the component implements.
+ * @param definition A ComponentDefinition type object, including display infromation, unique key, and a set of actions the component implements.
  * @returns This function returns a component object that has the shape the Prismatic API expects.
  */
-const component = (definition) => (Object.assign(Object.assign({ version: "placeholder" }, definition), { documentationUrl: definition.documentationUrl || null, actions: Object.fromEntries(Object.entries(definition.actions || {}).map(([actionKey, action]) => [
+const component = (definition) => (Object.assign(Object.assign({}, definition), { documentationUrl: definition.documentationUrl || null, actions: Object.fromEntries(Object.entries(definition.actions || {}).map(([actionKey, action]) => [
         actionKey,
         convertAction(actionKey, action),
     ])), triggers: Object.fromEntries(Object.entries(definition.triggers || {}).map(([triggerKey, trigger]) => [
         triggerKey,
         convertTrigger(triggerKey, trigger),
+    ])), connections: Object.fromEntries(Object.entries(definition.connections || {}).map(([connectionKey, connection]) => [
+        connectionKey,
+        convertConnection(connectionKey, connection),
     ])) }));
 exports.component = component;
 /**
@@ -94,8 +104,17 @@ exports.trigger = trigger;
  */
 const input = (definition) => definition;
 exports.input = input;
+/**
+ * For information on writing custom component connections, see
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#adding-connections.
+ * @param definition A ConnectionfieldDefinition object that describes the type of a connection for a custom component action or trigger, and information on how it should be displayed in the Prismatic WebApp.
+ * @returns This functions validates the shape of the `definition` object provided and returns the same connection object.
+ */
+const connection = (definition) => (Object.assign(Object.assign({}, definition), { type: "connection" }));
+exports.connection = connection;
 var util_1 = require("./util");
 Object.defineProperty(exports, "util", { enumerable: true, get: function () { return __importDefault(util_1).default; } });
 __exportStar(require("./types"), exports);
 var testing_1 = require("./testing");
 Object.defineProperty(exports, "testing", { enumerable: true, get: function () { return __importDefault(testing_1).default; } });
+__exportStar(require("./errors"), exports);

package/dist/testing.d.ts

@@ -5,30 +5,8 @@
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
 /** */
-import { ActionContext, ActionLogger, ActionDefinition, ActionInputParameters, Credential, BasicCredential, ApiKeyCredential, ApiKeySecretCredential, PrivateKeyCredential, OAuth2Credential, ActionPerformReturn, AuthorizationMethod, Inputs, TriggerDefinition, TriggerResult, TriggerPayload } from "./types";
-/**
- * Get an array of available authorization methods that a custom component can use.
- * @param except Return authorization methods _except for_ those in this array.
- * @returns This function returns an array of available authorization methods.
- */
-export declare const getAuthorizationMethods: (except?: ("basic" | "api_key" | "api_key_secret" | "private_key" | "oauth2" | "oauth2_client_credentials")[] | undefined) => AuthorizationMethod[];
-/** Utility functions to generate the different types of Credentials for testing. */
-export declare const credentials: {
-    /** Return a BasicCredential assembled from provided username and password. */
-    basic: (username: string, password: string) => BasicCredential;
-    /** Return a ApiKeyCredential assembled from provided key. */
-    apiKey: (key: string) => ApiKeyCredential;
-    /** Return a ApiKeySecretCredential assembled from provided key and secret. */
-    apiKeySecret: (key: string, secret: string) => ApiKeySecretCredential;
-    /** Return a PrivateKeyCredential assembled from provided username and privateKey. */
-    privateKey: (username: string, privateKey: string) => PrivateKeyCredential;
-    /** Return a OAuth2Credential assembled from provided token and optional redirectUri. */
-    oauth2: (token: string, redirectUri?: string, tokenUri?: string, clientId?: string, clientSecret?: string, headers?: {}) => OAuth2Credential;
-    /** Return a OAuth2Credential assembled from provided token. */
-    oauth2ClientCredentials: (token: string, redirectUri?: string, tokenUri?: string, clientId?: string, clientSecret?: string, headers?: {}) => OAuth2Credential;
-    /** Returns an arbitrary Credential using method. Generally used for testing negative support cases. */
-    generate: (method: AuthorizationMethod) => Credential;
-};
+import { ActionContext, ActionLogger, ActionDefinition, ActionInputParameters, ConnectionFieldDefinition, Connection, ActionPerformReturn, Inputs, TriggerDefinition, TriggerResult, TriggerPayload } from "./types";
+export declare const createConnection: <T extends ConnectionFieldDefinition>({ connectionKey }: T, values: { [Property in keyof T["inputs"]]: unknown; }) => Connection<T>;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
  * See https://prismatic.io/docs/custom-components/writing-custom-components/#verifying-correct-logging-in-action-tests for information on testing correct logging behavior in your custom component.
@@ -60,22 +38,5 @@ declare const _default: {
     invoke: <T extends Inputs, AllowsBranching extends boolean, ReturnData extends ActionPerformReturn<AllowsBranching, unknown>>(actionBase: ActionDefinition<T, AllowsBranching, ReturnData> | Record<string, ActionDefinition<T, AllowsBranching, ReturnData>>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<ReturnData>>;
     invokeTrigger: <T_1 extends Inputs, AllowsBranching_1 extends boolean, Result extends TriggerResult<AllowsBranching_1>>(triggerBase: TriggerDefinition<T_1, AllowsBranching_1, Result> | Record<string, TriggerDefinition<T_1, AllowsBranching_1, Result>>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T_1> | undefined) => Promise<InvokeReturn<Result>>;
     loggerMock: () => ActionLogger;
-    getAuthorizationMethods: (except?: ("basic" | "api_key" | "api_key_secret" | "private_key" | "oauth2" | "oauth2_client_credentials")[] | undefined) => ("basic" | "api_key" | "api_key_secret" | "private_key" | "oauth2" | "oauth2_client_credentials")[];
-    credentials: {
-        /** Return a BasicCredential assembled from provided username and password. */
-        basic: (username: string, password: string) => BasicCredential;
-        /** Return a ApiKeyCredential assembled from provided key. */
-        apiKey: (key: string) => ApiKeyCredential;
-        /** Return a ApiKeySecretCredential assembled from provided key and secret. */
-        apiKeySecret: (key: string, secret: string) => ApiKeySecretCredential;
-        /** Return a PrivateKeyCredential assembled from provided username and privateKey. */
-        privateKey: (username: string, privateKey: string) => PrivateKeyCredential;
-        /** Return a OAuth2Credential assembled from provided token and optional redirectUri. */
-        oauth2: (token: string, redirectUri?: string, tokenUri?: string, clientId?: string, clientSecret?: string, headers?: {}) => OAuth2Credential;
-        /** Return a OAuth2Credential assembled from provided token. */
-        oauth2ClientCredentials: (token: string, redirectUri?: string, tokenUri?: string, clientId?: string, clientSecret?: string, headers?: {}) => OAuth2Credential;
-        /** Returns an arbitrary Credential using method. Generally used for testing negative support cases. */
-        generate: (method: "basic" | "api_key" | "api_key_secret" | "private_key" | "oauth2" | "oauth2_client_credentials") => Credential;
-    };
 };
 export default _default;

package/dist/testing.js

@@ -15,85 +15,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.credentials = exports.getAuthorizationMethods = void 0;
-/** */
-const types_1 = require("./types");
+exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
 const jest_mock_1 = require("jest-mock");
-/**
- * Get an array of available authorization methods that a custom component can use.
- * @param except Return authorization methods _except for_ those in this array.
- * @returns This function returns an array of available authorization methods.
- */
-const getAuthorizationMethods = (except) => {
-    if (except === undefined) {
-        return types_1.AvailableAuthorizationMethods;
-    }
-    return types_1.AvailableAuthorizationMethods.filter((m) => !except.includes(m));
-};
-exports.getAuthorizationMethods = getAuthorizationMethods;
-/** Utility functions to generate the different types of Credentials for testing. */
-exports.credentials = {
-    /** Return a BasicCredential assembled from provided username and password. */
-    basic: (username, password) => ({
-        authorizationMethod: "basic",
-        fields: {
-            username,
-            password,
-        },
-    }),
-    /** Return a ApiKeyCredential assembled from provided key. */
-    apiKey: (key) => ({
-        authorizationMethod: "api_key",
-        fields: { api_key: key },
-    }),
-    /** Return a ApiKeySecretCredential assembled from provided key and secret. */
-    apiKeySecret: (key, secret) => ({
-        authorizationMethod: "api_key_secret",
-        fields: {
-            api_key: key,
-            api_secret: secret,
-        },
-    }),
-    /** Return a PrivateKeyCredential assembled from provided username and privateKey. */
-    privateKey: (username, privateKey) => ({
-        authorizationMethod: "private_key",
-        fields: {
-            username,
-            private_key: privateKey,
-        },
-    }),
-    /** Return a OAuth2Credential assembled from provided token and optional redirectUri. */
-    oauth2: (token, redirectUri = "", tokenUri = "", clientId = "", clientSecret = "", headers = {}) => ({
-        authorizationMethod: "oauth2",
-        redirectUri,
-        fields: {
-            client_id: clientId,
-            client_secret: clientSecret,
-            token_uri: tokenUri,
-            headers,
-        },
-        token: { access_token: token, token_type: "bearer" },
-        context: {},
-    }),
-    /** Return a OAuth2Credential assembled from provided token. */
-    oauth2ClientCredentials: (token, redirectUri = "", tokenUri = "", clientId = "", clientSecret = "", headers = {}) => ({
-        authorizationMethod: "oauth2_client_credentials",
-        redirectUri: redirectUri,
-        fields: {
-            client_id: clientId,
-            client_secret: clientSecret,
-            token_uri: tokenUri,
-            headers,
-        },
-        token: { access_token: token, token_type: "bearer" },
-        context: {},
-    }),
-    /** Returns an arbitrary Credential using method. Generally used for testing negative support cases. */
-    generate: (method) => ({
-        authorizationMethod: method,
-        fields: {},
-    }),
-};
+const createConnection = ({ connectionKey }, values) => ({
+    instanceConfigVarId: "",
+    key: connectionKey,
+    fields: values,
+});
+exports.createConnection = createConnection;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
  * See https://prismatic.io/docs/custom-components/writing-custom-components/#verifying-correct-logging-in-action-tests for information on testing correct logging behavior in your custom component.
@@ -114,7 +43,7 @@ exports.loggerMock = loggerMock;
  */
 const invoke = (actionBase, params, context) => __awaiter(void 0, void 0, void 0, function* () {
     const action = (actionBase.perform ? actionBase : Object.values(actionBase)[0]);
-    const realizedContext = Object.assign({ credential: undefined, logger: exports.loggerMock(), instanceState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
     const result = yield action.perform(realizedContext, params);
     return {
         result,
@@ -141,6 +70,9 @@ const defaultTriggerPayload = () => {
         webhookUrls: {
             "Flow 1": "https://example.com",
         },
+        webhookApiKeys: {
+            "Flow 1": ["example-123", "example-456"],
+        },
         customer: {
             name: "Customer 1",
             externalId: "1234",
@@ -156,7 +88,7 @@ exports.defaultTriggerPayload = defaultTriggerPayload;
  */
 const invokeTrigger = (triggerBase, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
     const trigger = (triggerBase.perform ? triggerBase : Object.values(triggerBase)[0]);
-    const realizedContext = Object.assign({ credential: undefined, logger: exports.loggerMock(), instanceState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
     const realizedPayload = Object.assign(Object.assign({}, exports.defaultTriggerPayload()), payload);
     const realizedParams = params || {};
     const result = yield trigger.perform(realizedContext, realizedPayload, realizedParams);
@@ -170,6 +102,4 @@ exports.default = {
     invoke: exports.invoke,
     invokeTrigger: exports.invokeTrigger,
     loggerMock: exports.loggerMock,
-    getAuthorizationMethods: exports.getAuthorizationMethods,
-    credentials: exports.credentials,
 };

package/dist/types/ActionDefinition.d.ts

@@ -1,4 +1,4 @@
-import { ActionPerformReturn, ActionDisplayDefinition, ActionPerformFunction, AuthorizationDefinition, Inputs } from ".";
+import { ActionPerformReturn, ActionDisplayDefinition, ActionPerformFunction, Inputs } from ".";
 /**
  * ActionDefinition is the type of the object that is passed in to `action` function to
  * define a component action.
@@ -10,8 +10,6 @@ export interface ActionDefinition<T extends Inputs, AllowsBranching extends bool
     perform: ActionPerformFunction<T, AllowsBranching, ReturnData>;
     /** InputFields to present in the Prismatic interface for configuration of this Action. */
     inputs: T;
-    /** Specifies Authorization settings, if applicable */
-    authorization?: AuthorizationDefinition;
     /** Optional attribute that specifies whether an Action will terminate execution.*/
     terminateExecution?: boolean;
     /** Determines whether an Action will allow Conditional Branching.*/

package/dist/types/ActionInputParameters.d.ts

@@ -1,14 +1,14 @@
-import { InputFieldDefinition, Inputs, InputFieldTypeMap } from ".";
+import { InputFieldDefinition, Inputs, InputFieldTypeMap, Connection, ConnectionFieldDefinition } from ".";
 /**
  * Collection of input parameters.
  * Inputs can be static values, references to config variables, or
- * references to previou steps' outputs.
+ * references to previous steps' outputs.
  */
-export declare type ActionInputParameters<T extends Inputs> = T extends Record<string, InputFieldDefinition> ? {
-    [K in keyof T]: ExtractValue<T[K]>;
-} : never;
+export declare type ActionInputParameters<TInputs extends Inputs> = {
+    [Property in keyof TInputs]: TInputs[Property] extends ConnectionFieldDefinition ? Connection<TInputs[Property]> : ExtractValue<TInputs[Property]>;
+};
 export declare type ExtractValue<TValue extends InputFieldDefinition> = MapCollectionValues<InputFieldTypeMap[TValue["type"]], TValue["collection"]>;
-export declare type MapCollectionValues<TValue, TCollection extends InputFieldDefinition["collection"] | undefined> = TCollection extends "keyvaluelist" ? KeyValuePair<TValue>[] | undefined : TCollection extends "valuelist" ? TValue[] | undefined : TValue;
+export declare type MapCollectionValues<TType, TCollection extends InputFieldDefinition["collection"] | undefined> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] | undefined : TCollection extends "valuelist" ? TType[] | undefined : TType;
 /**
  * KeyValuePair input parameter type.
  * This allows users to input multiple keys / values as an input.

package/dist/types/ActionPerformFunction.d.ts

@@ -1,10 +1,8 @@
-import { Credential, Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger } from ".";
+import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger } from ".";
 /** Definition of the function to perform when an Action is invoked. */
 export declare type ActionPerformFunction<T extends Inputs, AllowsBranching extends boolean, ReturnData extends ActionPerformReturn<AllowsBranching, unknown>> = (context: ActionContext, params: ActionInputParameters<T>) => Promise<ReturnData>;
 /** Context provided to perform method containing helpers and contextual data */
 export interface ActionContext {
-    /** Credential for the action, optional since not all actions will require a credential */
-    credential?: Credential;
     /** Logger for permanent logging; console calls are also captured */
     logger: ActionLogger;
     /** A key/value store that may be used to store small amounts of data that is persisted between Instance executions */

package/dist/types/ComponentDefinition.d.ts

@@ -0,0 +1,7 @@
+import { Component } from "./server-types";
+import { ActionPerformReturn, ActionDefinition, TriggerDefinition, TriggerResult, ConnectionFieldDefinition } from ".";
+export declare type ComponentDefinition<T extends boolean> = Omit<Component<T>, "actions" | "triggers" | "connections"> & {
+    actions?: Record<string, ActionDefinition<any, boolean, ActionPerformReturn<boolean, any>>>;
+    triggers?: Record<string, TriggerDefinition<any, boolean, TriggerResult<boolean>>>;
+    connections?: Record<string, ConnectionFieldDefinition>;
+};

package/dist/types/ComponentDefinition.js

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

package/dist/types/InputFieldType.d.ts

@@ -9,4 +9,5 @@ export declare type InputFieldTypeMap = {
     boolean: unknown;
     code: unknown;
     conditional: ConditionalExpression;
+    connection: never;
 };

package/dist/types/Inputs.d.ts

@@ -1,12 +1,12 @@
 import { InputFieldType } from ".";
 export declare type Inputs = Record<string, InputFieldDefinition>;
-export declare type InputFieldDefinition = DefaultInputFieldDefinition | CodeInputFieldDefinition;
-/** Defines attributes of a InputField. */
-export interface DefaultInputFieldDefinition {
+export declare type ConnectionInputs = Record<string, DefaultInputFieldDefinition & {
+    shown?: boolean;
+}>;
+export declare type InputFieldDefinition = DefaultInputFieldDefinition | CodeInputFieldDefinition | ConnectionFieldDefinition;
+interface BaseInputFieldDefinition {
     /** Interface label of the InputField. */
     label: string;
-    /** Data type the InputField will collect. */
-    type: InputFieldType;
     /** Collection type of the InputField */
     collection?: InputFieldCollection;
     /** Text to show as the InputField placeholder. */
@@ -22,10 +22,39 @@ export interface DefaultInputFieldDefinition {
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
 }
-export interface CodeInputFieldDefinition extends DefaultInputFieldDefinition {
-    type: "code";
+/** Defines attributes of a InputField. */
+export interface DefaultInputFieldDefinition extends BaseInputFieldDefinition {
+    type: Exclude<InputFieldType, "code" | "connection">;
+}
+/** Defines attributes of a CodeInputField. */
+export interface CodeInputFieldDefinition extends BaseInputFieldDefinition {
+    type: Extract<InputFieldType, "code">;
     language?: string;
 }
+export declare enum OAuth2Type {
+    ClientCredentials = "client_credentials",
+    AuthorizationCode = "authorization_code"
+}
+/** Defines attributes of a ConnectionField. */
+export interface ConnectionFieldDefinition extends BaseInputFieldDefinition {
+    type: Extract<InputFieldType, "connection">;
+    connectionKey: string;
+    oauth2Type?: OAuth2Type;
+    iconPath?: string;
+    inputs: ConnectionInputs;
+}
+export interface Connection<TField extends ConnectionFieldDefinition = ConnectionFieldDefinition> {
+    /** Key of the Connection type. */
+    key: TField["connectionKey"];
+    /** Identifier for the Config Variable hosting this Connection. */
+    instanceConfigVarId: string;
+    /** Field values supplied to this Connection. */
+    fields: {
+        [Property in keyof TField["inputs"]]: unknown;
+    };
+    token?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
 /** Defines a single Choice option for a InputField. */
 export interface InputFieldChoice {
     /** Label to display for this Choice. */
@@ -35,3 +64,4 @@ export interface InputFieldChoice {
 }
 /** InputField collection enumeration */
 export declare type InputFieldCollection = "valuelist" | "keyvaluelist";
+export {};

package/dist/types/Inputs.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Type = void 0;
+var OAuth2Type;
+(function (OAuth2Type) {
+    OAuth2Type["ClientCredentials"] = "client_credentials";
+    OAuth2Type["AuthorizationCode"] = "authorization_code";
+})(OAuth2Type = exports.OAuth2Type || (exports.OAuth2Type = {}));

package/dist/types/TriggerDefinition.d.ts

@@ -1,4 +1,4 @@
-import { TriggerResult, ActionDisplayDefinition, TriggerPerformFunction, AuthorizationDefinition, Inputs } from ".";
+import { TriggerResult, ActionDisplayDefinition, TriggerPerformFunction, Inputs } from ".";
 declare const optionChoices: readonly ["invalid", "valid", "required"];
 export declare type TriggerOptionChoice = typeof optionChoices[number];
 export declare const TriggerOptionChoices: TriggerOptionChoice[];
@@ -17,8 +17,6 @@ export interface TriggerDefinition<T extends Inputs, AllowsBranching extends boo
     scheduleSupport: TriggerOptionChoice;
     /** Specifies whether this Trigger supports synchronous responses to an Integration webhook request. */
     synchronousResponseSupport: TriggerOptionChoice;
-    /** Specifies Authorization settings, if applicable */
-    authorization?: AuthorizationDefinition;
     /** Optional attribute that specifies whether this Trigger will terminate execution. */
     terminateExecution?: boolean;
     /** Determines whether this Trigger allows Conditional Branching. */

package/dist/types/TriggerPayload.d.ts

@@ -14,9 +14,14 @@ export interface TriggerPayload {
         data: unknown;
         contentType?: string;
     };
+    /** The webhook URLs assigned to this integration's flows upon instance deploy */
     webhookUrls: {
         [key: string]: string;
     };
+    /** The optional API keys assigned to the flows of this integration. These may be unique per integration instance and per flow. */
+    webhookApiKeys: {
+        [key: string]: string[];
+    };
     customer: {
         externalId: string | null;
         name: string | null;

package/dist/types/index.d.ts

@@ -2,9 +2,8 @@
  * This file exports types from all other files in types/, so users can simply
  * `import { DesiredType } from "@prismatic-io/spectral"`
  */
-export * from "./Credential";
-export * from "./AuthorizationDefinition";
 export * from "./ActionDefinition";
+export * from "./ComponentDefinition";
 export * from "./Inputs";
 export * from "./ActionPerformReturn";
 export * from "./DisplayDefinition";

package/dist/types/index.js

@@ -27,9 +27,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serverTypes = void 0;
-__exportStar(require("./Credential"), exports);
-__exportStar(require("./AuthorizationDefinition"), exports);
 __exportStar(require("./ActionDefinition"), exports);
+__exportStar(require("./ComponentDefinition"), exports);
 __exportStar(require("./Inputs"), exports);
 __exportStar(require("./ActionPerformReturn"), exports);
 __exportStar(require("./DisplayDefinition"), exports);

package/dist/types/server-types.d.ts

@@ -6,29 +6,29 @@
  */
 /// <reference types="node" />
 /** Import shared types from types/ */
+import { OAuth2Type } from ".";
 import { ActionContext } from "./ActionPerformFunction";
-import { AuthorizationDefinition } from "./AuthorizationDefinition";
 import { ActionDisplayDefinition, ComponentDisplayDefinition } from "./DisplayDefinition";
 import { InputFieldChoice, InputFieldCollection } from "./Inputs";
 import { TriggerOptionChoice } from "./TriggerDefinition";
 import { TriggerPayload as _TriggerPayload } from "./TriggerPayload";
 import { TriggerBaseResult, TriggerBranchingResult } from "./TriggerResult";
 /** Defines attributes of a Component. */
-interface ComponentBase<T extends boolean> {
+interface ComponentBase<TPublic extends boolean> {
     /** Specifies unique key for this Component. */
     key: string;
     /** Specifies if this Component is available for all Organizations or only your own @default false */
-    public?: T;
+    public?: TPublic;
     /** Defines how the Component is displayed in the Prismatic interface. */
-    display: ComponentDisplayDefinition<T>;
-    /** @deprecated Version of the Component. */
-    version?: string;
+    display: ComponentDisplayDefinition<TPublic>;
     /** Specifies the supported Actions of this Component. */
     actions?: Record<string, Action>;
     /** Specifies the supported Triggers of this Component. */
     triggers?: Record<string, Trigger>;
+    /** Specifies the supported Connections of this Component. */
+    connections?: Record<string, ConnectionField>;
 }
-export declare type Component<T extends boolean> = ComponentBase<T> & (T extends true ? {
+export declare type Component<TPublic extends boolean> = ComponentBase<TPublic> & (TPublic extends true ? {
     /** Specified the URL for the Component Documentation. */
     documentationUrl: string;
 } : {
@@ -43,8 +43,6 @@ interface BaseAction {
     display: ActionDisplayDefinition;
     /** InputFields to present in the Prismatic interface for configuration of this Action. */
     inputs: InputField[];
-    /** Specifies Authorization settings, if applicable */
-    authorization?: AuthorizationDefinition;
     /** Optional attribute that specifies whether an Action will terminate execution. */
     terminateExecution?: boolean;
     /** Determines whether an Action will allow Conditional Branching. */
@@ -118,7 +116,7 @@ export declare type TriggerResult = TriggerBranchingResult | TriggerBaseResult |
 /** Definition of the function to perform when a Trigger is invoked. */
 export declare type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: ActionInputParameters) => Promise<TriggerResult>;
 export declare type TriggerPayload = _TriggerPayload;
-export declare type InputField = DefaultInputField | CodeInputField;
+export declare type InputField = DefaultInputField | CodeInputField | ConnectionField;
 /** Defines attributes of a InputField. */
 interface DefaultInputField {
     /** Unique identifier of the InputField. Must be unique within an Action. */
@@ -146,8 +144,17 @@ interface CodeInputField extends DefaultInputField {
     type: "code";
     language?: string;
 }
+export interface ConnectionField extends DefaultInputField {
+    type: "connection";
+    key: string;
+    oauth2Type?: OAuth2Type;
+    iconPath?: string;
+    inputs: (Exclude<InputField, ConnectionField> & {
+        shown?: boolean;
+    })[];
+}
 /** InputField type enumeration. */
-export declare type InputFieldType = "string" | "text" | "password" | "boolean" | "code" | "data" | "conditional";
+export declare type InputFieldType = "string" | "text" | "password" | "boolean" | "code" | "data" | "conditional" | "connection";
 /** Binary data payload */
 export interface DataPayload {
     /** Raw binary data as a Buffer */

package/dist/util.d.ts

@@ -5,6 +5,16 @@
  */
 import { DataPayload } from "./types/server-types";
 import { KeyValuePair } from "./types";
+/**
+ * This function returns a lower cased version of the headers passed to it.
+ *
+ * - `lowerCaseHeaders({"Content-Type": "Application/JSON"}) will return {"content-type": "Application/JSON"}`
+ * - `lowerCaseHeaders({"Cache-Control": "max-age=604800"}) will return {"cache-control": "max-age=604800"}`
+ * - `lowerCaseHeaders({"Accept-Language": "en-us"}) will return {"accept-language": "en-us"}`
+ * @param headers The headers to convert to lower case
+ * @returns This function returns a header object
+ * */
+export declare const lowerCaseHeaders: (headers: Record<string, string>) => Record<string, string>;
 declare const _default: {
     types: {
         isBool: (value: unknown) => value is boolean;
@@ -25,6 +35,7 @@ declare const _default: {
         toString: (value: unknown, defaultValue?: string) => string;
         keyValPairListToObject: (kvpList?: KeyValuePair<unknown>[]) => Record<string, unknown>;
         isJSON: (value: string) => boolean;
+        lowerCaseHeaders: (headers: Record<string, string>) => Record<string, string>;
     };
     docs: {
         formatJsonExample: (input: unknown) => string;

package/dist/util.js

@@ -8,6 +8,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerCaseHeaders = void 0;
 /** */
 const parseISO_1 = __importDefault(require("date-fns/parseISO"));
 const isValid_1 = __importDefault(require("date-fns/isValid"));
@@ -97,7 +98,7 @@ const toInt = (value, defaultValue) => {
  * - `util.types.isBool("5.5")` will return `true`, since the string `"5.5"` can easily be coerced into a number.
  * - `util.types.isBool("Hello")` will return `false`, since `"Hello"` is not a number.
  *
- * @param value The varible to test.
+ * @param value The variable to test.
  * @returns This function returns true if `value` can easily be coerced into a number, and false otherwise.
  */
 const isNumber = (value) => !Number.isNaN(Number(value));
@@ -310,6 +311,19 @@ const isJSON = (value) => {
         return false;
     }
 };
+/**
+ * This function returns a lower cased version of the headers passed to it.
+ *
+ * - `lowerCaseHeaders({"Content-Type": "Application/JSON"}) will return {"content-type": "Application/JSON"}`
+ * - `lowerCaseHeaders({"Cache-Control": "max-age=604800"}) will return {"cache-control": "max-age=604800"}`
+ * - `lowerCaseHeaders({"Accept-Language": "en-us"}) will return {"accept-language": "en-us"}`
+ * @param headers The headers to convert to lower case
+ * @returns This function returns a header object
+ * */
+const lowerCaseHeaders = (headers) => Object.entries(headers).reduce((result, [key, val]) => {
+    return Object.assign(Object.assign({}, result), { [key.toLowerCase()]: val });
+}, {});
+exports.lowerCaseHeaders = lowerCaseHeaders;
 exports.default = {
     types: {
         isBool,
@@ -330,6 +344,7 @@ exports.default = {
         toString,
         keyValPairListToObject,
         isJSON,
+        lowerCaseHeaders: exports.lowerCaseHeaders,
     },
     docs: {
         formatJsonExample,

package/dist/util.test.js

@@ -283,4 +283,23 @@ describe("util", () => {
             }));
         });
     });
+    const validJSON = fast_check_1.default.jsonObject().map((x) => JSON.stringify(x));
+    const invalidJSON = fast_check_1.default.constantFrom("", "['']", "someString", null, undefined);
+    describe("JSON", () => {
+        it("returns true in the case of actual JSON", () => {
+            fast_check_1.default.assert(fast_check_1.default.property(validJSON, (v) => {
+                expect(util_1.default.types.isJSON(v)).toStrictEqual(true);
+            }));
+        });
+        it("returns false in the case of invalid JSON", () => {
+            fast_check_1.default.assert(fast_check_1.default.property(invalidJSON, (v) => {
+                expect(util_1.default.types.isJSON(util_1.default.types.toString(v))).toStrictEqual(false);
+            }));
+        });
+        describe("JSON", () => {
+            it("returns true in the case of actual JSON", () => {
+                expect(util_1.default.types.lowerCaseHeaders({ "Content-Type": "Application/Json" })).toStrictEqual({ "content-type": "Application/Json" });
+            });
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "4.0.6",
+  "version": "5.0.0-rc.0",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"

package/dist/types/AuthorizationDefinition.d.ts

@@ -1,14 +0,0 @@
-/** Authorization settings for a component */
-export interface AuthorizationDefinition {
-    /** Whether authorization is required */
-    required: boolean;
-    /** Supported authorization methods */
-    methods: AuthorizationMethod[];
-}
-declare const authorizationMethods: readonly ["basic", "api_key", "api_key_secret", "private_key", "oauth2", "oauth2_client_credentials"];
-export declare type AuthorizationMethod = typeof authorizationMethods[number];
-export declare const AvailableAuthorizationMethods: AuthorizationMethod[];
-declare const oauth2AuthorizationMethods: readonly ["oauth2", "oauth2_client_credentials"];
-export declare type OAuth2AuthorizationMethod = typeof oauth2AuthorizationMethods[number];
-export declare const AvailableOAuth2AuthorizationMethods: OAuth2AuthorizationMethod[];
-export {};

package/dist/types/AuthorizationDefinition.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvailableOAuth2AuthorizationMethods = exports.AvailableAuthorizationMethods = void 0;
-const authorizationMethods = [
-    "basic",
-    "api_key",
-    "api_key_secret",
-    "private_key",
-    "oauth2",
-    "oauth2_client_credentials",
-];
-exports.AvailableAuthorizationMethods = [
-    ...authorizationMethods,
-];
-const oauth2AuthorizationMethods = [
-    "oauth2",
-    "oauth2_client_credentials",
-];
-exports.AvailableOAuth2AuthorizationMethods = [...oauth2AuthorizationMethods];

package/dist/types/Credential.d.ts

@@ -1,58 +0,0 @@
-/**
- * Types defined in this file describe the shape of credentials
- * that can be passed to actions' perform functions.
- * Read about the credential object at:
- * https://prismatic.io/docs/custom-components/writing-custom-components#contextcredential
- */
-/** */
-import { OAuth2AuthorizationMethod } from ".";
-export declare type Credential = BasicCredential | ApiKeyCredential | ApiKeySecretCredential | PrivateKeyCredential | OAuth2Credential;
-export interface BasicCredential {
-    authorizationMethod: "basic";
-    fields: {
-        username: string;
-        password: string;
-    };
-}
-export interface ApiKeyCredential {
-    authorizationMethod: "api_key";
-    fields: {
-        api_key: string;
-    };
-}
-export interface ApiKeySecretCredential {
-    authorizationMethod: "api_key_secret";
-    fields: {
-        api_key: string;
-        api_secret: string;
-    };
-}
-export interface PrivateKeyCredential {
-    authorizationMethod: "private_key";
-    fields: {
-        username: string;
-        private_key: string;
-    };
-}
-export interface OAuth2Credential {
-    authorizationMethod: OAuth2AuthorizationMethod;
-    redirectUri: string;
-    fields: {
-        client_id: string;
-        client_secret: string;
-        token_uri: string;
-        auth_uri?: string;
-        scopes?: string;
-        headers?: Record<string, string>;
-    };
-    token: {
-        access_token: string;
-        token_type: string;
-        refresh_token?: string;
-        expires_in?: string;
-        [key: string]: string | undefined;
-    };
-    context: {
-        [key: string]: string;
-    };
-}

package/dist/types/Credential.js

@@ -1,8 +0,0 @@
-"use strict";
-/**
- * Types defined in this file describe the shape of credentials
- * that can be passed to actions' perform functions.
- * Read about the credential object at:
- * https://prismatic.io/docs/custom-components/writing-custom-components#contextcredential
- */
-Object.defineProperty(exports, "__esModule", { value: true });