@prismatic-io/spectral 6.6.1 → 7.0.2-pre

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 } from "./types";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition, DataSourceResult } from "./types";
 import { convertComponent } from "./serverTypes/convert";
 /**
  * This function creates a component object that can be
@@ -34,6 +34,16 @@ export declare const action: <TInputs extends Inputs, TAllowsBranching extends b
  * @returns This function validates the shape of the `definition` object provided, and returns the same trigger object.
  */
 export declare const trigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>>(definition: TriggerDefinition<TInputs, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TAllowsBranching, TResult>;
+/**
+ * This function creates a data source object that can be referenced
+ * by a custom component. It helps ensure that the shape of the
+ * data source object conforms to what the Prismatic API expects.
+ * For information on writing custom component data sources, see
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#writing-data-sources.
+ * @param definition A DataSourceDefinition type object that includes UI display information, a function to perform when the data source 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 data source object.
+ */
+export declare const dataSource: <TInputs extends Inputs, TResult extends DataSourceResult<unknown>>(definition: DataSourceDefinition<TInputs, TResult>) => DataSourceDefinition<TInputs, TResult>;
 /**
  * For information and examples on how to write inputs
  * for custom component actions and triggers, see

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.trigger = exports.action = exports.component = void 0;
+exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = void 0;
 const convert_1 = require("./serverTypes/convert");
 /**
  * This function creates a component object that can be
@@ -56,6 +56,17 @@ exports.action = action;
  */
 const trigger = (definition) => definition;
 exports.trigger = trigger;
+/**
+ * This function creates a data source object that can be referenced
+ * by a custom component. It helps ensure that the shape of the
+ * data source object conforms to what the Prismatic API expects.
+ * For information on writing custom component data sources, see
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#writing-data-sources.
+ * @param definition A DataSourceDefinition type object that includes UI display information, a function to perform when the data source 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 data source object.
+ */
+const dataSource = (definition) => definition;
+exports.dataSource = dataSource;
 /**
  * For information and examples on how to write inputs
  * for custom component actions and triggers, see

package/dist/serverTypes/convert.d.ts

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

package/dist/serverTypes/convert.js

@@ -39,15 +39,24 @@ const convertTrigger = (triggerKey, _a, hooks) => {
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
         }) });
 };
+const convertDataSource = (dataSourceKey, _a, hooks) => {
+    var { inputs = {}, perform } = _a, dataSource = __rest(_a, ["inputs", "perform"]);
+    const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
+    return Object.assign(Object.assign({}, dataSource), { key: dataSourceKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
+            inputCleaners: {},
+            errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
+        }) });
+};
 const convertConnection = (_a) => {
     var { inputs = {} } = _a, connection = __rest(_a, ["inputs"]);
     const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
     return Object.assign(Object.assign({}, connection), { inputs: convertedInputs });
 };
 const convertComponent = (_a) => {
-    var { connections = [], actions = {}, triggers = {}, hooks } = _a, definition = __rest(_a, ["connections", "actions", "triggers", "hooks"]);
+    var { connections = [], actions = {}, triggers = {}, dataSources = {}, hooks } = _a, definition = __rest(_a, ["connections", "actions", "triggers", "dataSources", "hooks"]);
     const convertedActions = Object.entries(actions).reduce((result, [actionKey, action]) => (Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, action, hooks) })), {});
     const convertedTriggers = Object.entries(triggers).reduce((result, [triggerKey, trigger]) => (Object.assign(Object.assign({}, result), { [triggerKey]: convertTrigger(triggerKey, trigger, hooks) })), {});
-    return Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: convertedActions, triggers: convertedTriggers });
+    const convertedDataSources = Object.entries(dataSources).reduce((result, [dataSourceKey, dataSource]) => (Object.assign(Object.assign({}, result), { [dataSourceKey]: convertDataSource(dataSourceKey, dataSource, hooks) })), {});
+    return Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: convertedActions, triggers: convertedTriggers, dataSources: convertedDataSources });
 };
 exports.convertComponent = convertComponent;

package/dist/serverTypes/index.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { DataSourceResultType, DataSourceResultFieldType } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -13,6 +14,7 @@ export interface Component {
     };
     actions: Record<string, Action>;
     triggers: Record<string, Trigger>;
+    dataSources: Record<string, DataSource>;
     connections: Connection[];
 }
 export interface Action {
@@ -125,6 +127,25 @@ export interface Trigger {
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
 }
+export declare type DataSourceResult = {
+    result: DataSourceResultType;
+    supplementalData: {
+        data: unknown;
+        contentType: string;
+    };
+};
+export declare type DataSourcePerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<DataSourceResult>;
+export interface DataSource {
+    key: string;
+    display: DisplayDefinition & {
+        directions?: string;
+        important?: boolean;
+    };
+    inputs: Input[];
+    perform: DataSourcePerformFunction;
+    resultFieldType: DataSourceResultFieldType;
+    examplePayload?: unknown;
+}
 export declare enum OAuth2Type {
     ClientCredentials = "client_credentials",
     AuthorizationCode = "authorization_code"

package/dist/testing.d.ts

@@ -4,8 +4,8 @@
  * information on unit testing, check out our docs:
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
-import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn } from "./serverTypes";
-import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult } from "./types";
+import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn, DataSourceResult } from "./serverTypes";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>) => ConnectionValue;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
@@ -34,12 +34,20 @@ export declare const defaultTriggerPayload: () => TriggerPayload;
  * trigger result and a mock logger for asserting logging.
  */
 export declare const invokeTrigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching>>({ perform }: TriggerDefinition<TInputs, TAllowsBranching, TResult>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs> | undefined) => Promise<InvokeReturn<TResult>>;
+/**
+ * Invokes specified DataSourceDefinition perform function using supplied params
+ * and optional context. Accepts a generic type matching DataSourceResult as a convenience
+ * 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 invokeDataSource: <TInputs extends Inputs, TReturn extends InvokeDataSourceResult<unknown>>({ perform }: DataSourceDefinition<TInputs, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
     connectionValue({ key }: ConnectionDefinition): ConnectionValue;
     trigger(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<TriggerResult>;
     action(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<ActionPerformReturn>;
+    dataSource(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<DataSourceResult>;
 }
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
@@ -47,5 +55,6 @@ declare const _default: {
     invoke: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform }: ActionDefinition<TInputs, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
     invokeTrigger: <TInputs_1 extends Inputs, TAllowsBranching_1 extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching_1>>({ perform }: TriggerDefinition<TInputs_1, TAllowsBranching_1, TResult>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs_1> | undefined) => Promise<InvokeReturn<TResult>>;
     createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
+    invokeDataSource: <TInputs_2 extends Inputs, TReturn_1 extends InvokeDataSourceResult<unknown>>({ perform }: DataSourceDefinition<TInputs_2, TReturn_1>, params: ActionInputParameters<TInputs_2>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn_1>>;
 };
 export default _default;

package/dist/testing.js

@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHarness = exports.ComponentTestHarness = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
+exports.createHarness = exports.ComponentTestHarness = exports.invokeDataSource = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
 const jest_mock_1 = require("jest-mock");
 const createConnection = ({ key }, values) => ({
     configVarKey: "",
@@ -37,6 +37,30 @@ const loggerMock = () => ({
     error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
+const baseContext = {
+    logger: (0, exports.loggerMock)(),
+    instanceState: {},
+    crossFlowState: {},
+    executionState: {},
+    stepId: "mockStepId",
+    executionId: "mockExecutionId",
+    webhookUrls: {
+        "Flow 1": "https://example.com",
+    },
+    webhookApiKeys: {
+        "Flow 1": ["example-123", "example-456"],
+    },
+    invokeUrl: "https://example.com",
+    customer: {
+        id: "customerId",
+        name: "Customer 1",
+        externalId: "1234",
+    },
+    instance: {
+        id: "instanceId",
+        name: "Instance 1",
+    },
+};
 /**
  * Invokes specified ActionDefinition perform function using supplied params
  * and optional context. Accepts a generic type matching ActionPerformReturn as a convenience
@@ -44,18 +68,7 @@ exports.loggerMock = loggerMock;
  * action result and a mock logger for asserting logging.
  */
 const invoke = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-            "Flow 1": "https://example.com",
-        }, webhookApiKeys: {
-            "Flow 1": ["example-123", "example-456"],
-        }, invokeUrl: "https://example.com", customer: {
-            id: "customerId",
-            name: "Customer 1",
-            externalId: "1234",
-        }, instance: {
-            id: "instanceId",
-            name: "Instance 1",
-        } }, context);
+    const realizedContext = Object.assign(Object.assign({}, baseContext), context);
     const result = yield perform(realizedContext, params);
     return {
         result,
@@ -107,18 +120,7 @@ exports.defaultTriggerPayload = defaultTriggerPayload;
  * trigger result and a mock logger for asserting logging.
  */
 const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-            "Flow 1": "https://example.com",
-        }, webhookApiKeys: {
-            "Flow 1": ["example-123", "example-456"],
-        }, invokeUrl: "https://example.com", customer: {
-            id: "customerId",
-            name: "Customer 1",
-            externalId: "1234",
-        }, instance: {
-            id: "instanceId",
-            name: "Instance 1",
-        } }, context);
+    const realizedContext = Object.assign(Object.assign({}, baseContext), context);
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const realizedParams = params || {};
     const result = yield perform(realizedContext, realizedPayload, realizedParams);
@@ -128,6 +130,21 @@ const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void
     };
 });
 exports.invokeTrigger = invokeTrigger;
+/**
+ * Invokes specified DataSourceDefinition perform function using supplied params
+ * and optional context. Accepts a generic type matching DataSourceResult as a convenience
+ * to avoid extra casting within test methods. Returns an InvokeResult containing both the
+ * action result and a mock logger for asserting logging.
+ */
+const invokeDataSource = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = Object.assign(Object.assign({}, baseContext), context);
+    const result = yield perform(realizedContext, params);
+    return {
+        result,
+        loggerMock: realizedContext.logger,
+    };
+});
+exports.invokeDataSource = invokeDataSource;
 class ComponentTestHarness {
     constructor(component) {
         this.component = component;
@@ -142,40 +159,25 @@ class ComponentTestHarness {
     }
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-                    "Flow 1": "https://example.com",
-                }, webhookApiKeys: {
-                    "Flow 1": ["example-123", "example-456"],
-                }, invokeUrl: "https://example.com", customer: {
-                    id: "customerId",
-                    name: "Customer 1",
-                    externalId: "1234",
-                }, instance: {
-                    id: "instanceId",
-                    name: "Instance 1",
-                } }, context);
+            const realizedContext = Object.assign(Object.assign({}, baseContext), context);
             const trigger = this.component.triggers[key];
             return trigger.perform(realizedContext, Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), Object.assign({}, params));
         });
     }
     action(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
-                    "Flow 1": "https://example.com",
-                }, webhookApiKeys: {
-                    "Flow 1": ["example-123", "example-456"],
-                }, invokeUrl: "https://example.com", customer: {
-                    id: "customerId",
-                    name: "Customer 1",
-                    externalId: "1234",
-                }, instance: {
-                    id: "instanceId",
-                    name: "Instance 1",
-                } }, context);
+            const realizedContext = Object.assign(Object.assign({}, baseContext), context);
             const action = this.component.actions[key];
             return action.perform(realizedContext, Object.assign({}, params));
         });
     }
+    dataSource(key, params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const realizedContext = Object.assign(Object.assign({}, baseContext), context);
+            const dataSource = this.component.dataSources[key];
+            return dataSource.perform(realizedContext, Object.assign({}, params));
+        });
+    }
 }
 exports.ComponentTestHarness = ComponentTestHarness;
 const createHarness = (component) => {
@@ -187,4 +189,5 @@ exports.default = {
     invoke: exports.invoke,
     invokeTrigger: exports.invokeTrigger,
     createHarness: exports.createHarness,
+    invokeDataSource: exports.invokeDataSource,
 };

package/dist/types/ActionPerformReturn.d.ts

@@ -12,7 +12,7 @@ export interface ActionPerformDataReturn<ReturnData> {
     crossFlowState?: Record<string, unknown>;
     /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
     executionState?: Record<string, unknown>;
-    /** A field populated by the Prismatic platform which indicates whether the trigger failed with an error during execution. */
+    /** A field populated by the Prismatic platform which indicates whether the action failed with an error during execution. */
     failed?: boolean;
     /** A field populated by the Prismatic platform which may refer to an object that contains data about any error that resulted in failure. */
     error?: Record<string, unknown>;

package/dist/types/ComponentDefinition.d.ts

@@ -1,4 +1,4 @@
-import { ActionDefinition, ConnectionDefinition, ComponentDisplayDefinition, TriggerDefinition } from ".";
+import { ActionDefinition, ConnectionDefinition, ComponentDisplayDefinition, TriggerDefinition, DataSourceDefinition } from ".";
 export declare type ErrorHandler = (error: unknown) => unknown;
 export interface ComponentHooks {
     /** Defines a global error handler that automatically wraps the component's action/trigger perform functions. */
@@ -16,6 +16,8 @@ export declare type ComponentDefinition<TPublic extends boolean> = {
     actions?: Record<string, ActionDefinition<any, boolean, any>>;
     /** Specifies the supported Triggers of this Component. */
     triggers?: Record<string, TriggerDefinition<any, boolean, any>>;
+    /** Specifies the supported Data Sources of this Component. */
+    dataSources?: Record<string, DataSourceDefinition<any, any>>;
     /** Specifies the supported Connections of this Component. */
     connections?: ConnectionDefinition[];
     /** Hooks */

package/dist/types/DataSourceDefinition.d.ts

@@ -0,0 +1,17 @@
+import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceResult, DataSourceResultType, DataSourceResultFieldType } from ".";
+/**
+ * DataSourceDefinition is the type of the object that is passed in to `dataSource` function to
+ * define a component Data Source.
+ */
+export interface DataSourceDefinition<TInputs extends Inputs, TDataSourceResult extends DataSourceResult<DataSourceResultType>> {
+    /** Defines how the Data Source is displayed in the Prismatic interface. */
+    display: ActionDisplayDefinition;
+    /** Function to perform when this Data Source is invoked. */
+    perform: DataSourcePerformFunction<TInputs, TDataSourceResult>;
+    /** Field type of the data produced by the data source perform function. */
+    resultFieldType: DataSourceResultFieldType;
+    /** InputFields to present in the Prismatic interface for configuration of this Data Source. */
+    inputs: TInputs;
+    /** An example of the payload outputted by this Data Source. */
+    examplePayload?: Awaited<ReturnType<this["perform"]>>;
+}

package/dist/types/DataSourceDefinition.js

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

package/dist/types/DataSourcePerformFunction.d.ts

@@ -0,0 +1,3 @@
+import { Inputs, DataSourceResult, DataSourceResultType, ActionInputParameters, ActionContext } from ".";
+/** Definition of the function to perform when a Data Source is invoked. */
+export declare type DataSourcePerformFunction<T extends Inputs, TResult extends DataSourceResult<DataSourceResultType>> = (context: ActionContext, params: ActionInputParameters<T>) => Promise<TResult>;

package/dist/types/DataSourcePerformFunction.js

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

package/dist/types/DataSourceResult.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ObjectSelection, ObjectFieldMap, InputFieldDefaultMap } from "./Inputs";
+/** The type of field that is appropriate for rendering the data that is the result of the data source perform function. */
+export declare type DataSourceResultFieldType = keyof typeof InputFieldDefaultMap;
+/** The actual data type of the data that is the result of the data source perform function. */
+export declare type DataSourceResultType = ObjectSelection | ObjectFieldMap | Buffer | boolean | number | string | Record<string, unknown> | unknown[] | unknown;
+/** Represents the result of a Data Source action. */
+export declare type DataSourceResult<TDataSourceResultType> = {
+    /** The resulting data that is returned from the data source. */
+    result: TDataSourceResultType;
+    /** Additional data that may be useful for out-of-band processing at a later time. */
+    supplementalData?: {
+        data: unknown;
+        contentType: string;
+    };
+};

package/dist/types/DataSourceResult.js

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

package/dist/types/Inputs.d.ts

@@ -1,4 +1,22 @@
 import { ConditionalExpression } from "./conditional-logic";
+export declare type ObjectSelection = {
+    key: string;
+    label?: string;
+    fields: {
+        key: string;
+        label?: string;
+    }[];
+}[];
+export declare type ObjectFieldMap = {
+    key: string;
+    label?: string;
+    value: {
+        objectKey: string;
+        objectLabel?: string;
+        fieldKey: string;
+        fieldLabel?: string;
+    };
+}[];
 /** InputField type enumeration. */
 export declare type InputFieldType = InputFieldDefinition["type"];
 export declare const InputFieldDefaultMap: Record<InputFieldType, string | undefined>;
@@ -6,7 +24,7 @@ export declare type Inputs = Record<string, InputFieldDefinition>;
 export declare type ConnectionInput = (StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField) & {
     shown?: boolean;
 };
-export declare type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField;
+export declare type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField | ObjectSelectionInputField | ObjectFieldMapInputField;
 export declare type InputCleanFunction<TValue, TResult = TValue> = (value: TValue) => TResult;
 interface BaseInputField {
     /** Interface label of the InputField. */
@@ -132,6 +150,28 @@ export interface Connection {
     token?: Record<string, unknown>;
     context?: Record<string, unknown>;
 }
+/** Defines attributes of an ObjectSelectionInputField. */
+export interface ObjectSelectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "objectselection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: ObjectSelection;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of an ObjectFieldMapInputField. */
+export interface ObjectFieldMapInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "objectfieldmap";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: ObjectFieldMap;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
 /** Defines a single Choice option for a InputField. */
 export interface InputFieldChoice {
     /** Label to display for this Choice. */

package/dist/types/Inputs.js

@@ -10,4 +10,6 @@ exports.InputFieldDefaultMap = {
     code: "",
     conditional: undefined,
     connection: undefined,
+    objectselection: undefined,
+    objectfieldmap: undefined,
 };

package/dist/types/index.d.ts

@@ -18,3 +18,7 @@ export * from "./TriggerPerformFunction";
 export * from "./TriggerDefinition";
 export * from "./HttpResponse";
 export * from "./TriggerPayload";
+export * from "./DataSourceDefinition";
+export * from "./DataSourcePerformFunction";
+export * from "./DataSourceResult";
+export * as serverTypes from "../serverTypes";

package/dist/types/index.js

@@ -14,10 +14,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverTypes = void 0;
 __exportStar(require("./ActionDefinition"), exports);
 __exportStar(require("./ComponentDefinition"), exports);
 __exportStar(require("./ConnectionDefinition"), exports);
@@ -34,3 +47,7 @@ __exportStar(require("./TriggerPerformFunction"), exports);
 __exportStar(require("./TriggerDefinition"), exports);
 __exportStar(require("./HttpResponse"), exports);
 __exportStar(require("./TriggerPayload"), exports);
+__exportStar(require("./DataSourceDefinition"), exports);
+__exportStar(require("./DataSourcePerformFunction"), exports);
+__exportStar(require("./DataSourceResult"), exports);
+exports.serverTypes = __importStar(require("../serverTypes"));

package/dist/util.d.ts

@@ -3,7 +3,7 @@
  * Many functions in the `util` module are used to coerce data into a particular type, and can be accessed through `util.types`.
  * For example, `util.types.toInt("5.5")` will return an integer, `5`.
  */
-import { KeyValuePair, DataPayload } from "./types";
+import { KeyValuePair, DataPayload, ObjectSelection, ObjectFieldMap } from "./types";
 /**
  * This function returns a lower cased version of the headers passed to it.
  *
@@ -36,6 +36,10 @@ declare const _default: {
         isJSON: (value: string) => boolean;
         toJSON: (value: unknown) => string;
         lowerCaseHeaders: (headers: Record<string, string>) => Record<string, string>;
+        isObjectSelection: (value: unknown) => value is ObjectSelection;
+        toObjectSelection: (value: unknown) => ObjectSelection;
+        isObjectFieldMap: (value: unknown) => value is ObjectFieldMap;
+        toObjectFieldMap: (value: unknown) => ObjectFieldMap;
     };
     docs: {
         formatJsonExample: (input: unknown) => string;

package/dist/util.js

@@ -15,6 +15,81 @@ const isValid_1 = __importDefault(require("date-fns/isValid"));
 const isDate_1 = __importDefault(require("date-fns/isDate"));
 const safe_stable_stringify_1 = require("safe-stable-stringify");
 const valid_url_1 = require("valid-url");
+const isObjectWithTruthyKeys = (value, keys) => {
+    return (value !== null &&
+        typeof value === "object" &&
+        keys.every((key) => key in value && Boolean(value === null || value === void 0 ? void 0 : value[key])));
+};
+/**
+ * @param value The value to test
+ * @returns This function returns true if the type of `value` is an ObjectSelection, or false otherwise.
+ */
+const isObjectSelection = (value) => {
+    if (Array.isArray(value)) {
+        for (const selection of value) {
+            if (isObjectWithTruthyKeys(selection, ["key", "fields"])) {
+                const { fields } = selection;
+                if (!Array.isArray(fields) ||
+                    fields.length === 0 ||
+                    !fields.every((field) => isObjectWithTruthyKeys(field, ["key"]))) {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    else {
+        return false;
+    }
+    return true;
+};
+/**
+ * This function coerces a provided value into an ObjectSelection if possible.
+ * @param value The value to coerce to ObjectSelection.
+ * @returns This function returns the the value as an ObjectSelection if possible.
+ */
+const toObjectSelection = (value) => {
+    if (isObjectSelection(value)) {
+        return value;
+    }
+    throw new Error(`Value '${value}' cannot be coerced to ObjectSelection.`);
+};
+/**
+ * @param value The value to test
+ * @returns This function returns true if the type of `value` is an ObjectFieldMap, or false otherwise.
+ */
+const isObjectFieldMap = (value) => {
+    if (Array.isArray(value)) {
+        for (const fieldMap of value) {
+            if (isObjectWithTruthyKeys(fieldMap, ["key", "value"])) {
+                const { value: val } = fieldMap;
+                if (!isObjectWithTruthyKeys(val, ["objectKey", "fieldKey"])) {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    else {
+        return false;
+    }
+    return true;
+};
+/**
+ * This function coerces a provided value into an ObjectFieldMap if possible.
+ * @param value The value to coerce to ObjectFieldMap.
+ * @returns This function returns the the value as an ObjectFieldMap if possible.
+ */
+const toObjectFieldMap = (value) => {
+    if (isObjectFieldMap(value)) {
+        return value;
+    }
+    throw new Error(`Value '${value}' cannot be coerced to ObjectFieldMap.`);
+};
 /**
  * Determine if a variable is a boolean (true or false).
  *
@@ -357,6 +432,10 @@ exports.default = {
         isJSON,
         toJSON,
         lowerCaseHeaders: exports.lowerCaseHeaders,
+        isObjectSelection,
+        toObjectSelection,
+        isObjectFieldMap,
+        toObjectFieldMap,
     },
     docs: {
         formatJsonExample,

package/package.json

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