@prismatic-io/spectral 7.0.0-pre → 7.0.0

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, DataSourceResult } from "./types";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition } from "./types";
 import { convertComponent } from "./serverTypes/convert";
 /**
  * This function creates a component object that can be
@@ -43,7 +43,23 @@ export declare const trigger: <TInputs extends Inputs, TAllowsBranching extends
  * @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>;
+export declare const dataSource: <TInputs extends Inputs, TDataSourceType extends keyof {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string[];
+    schedule: {
+        value: string;
+    };
+    code: string;
+    credential: unknown;
+    boolean: boolean;
+    number: number;
+    connection: import("./types").ConnectionDefinition;
+    objectSelection: import("./types").ObjectSelection;
+    objectFieldMap: import("./types").ObjectFieldMap;
+    jsonForm: import("./types").JSONForm;
+}>(definition: DataSourceDefinition<TInputs, TDataSourceType>) => DataSourceDefinition<TInputs, TDataSourceType>;
 /**
  * For information and examples on how to write inputs
  * for custom component actions and triggers, see

package/dist/serverTypes/convert.js

@@ -34,16 +34,18 @@ const convertAction = (actionKey, _a, hooks) => {
 const convertTrigger = (triggerKey, _a, hooks) => {
     var { inputs = {}, perform } = _a, trigger = __rest(_a, ["inputs", "perform"]);
     const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
+    const inputCleaners = Object.entries(inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
     return Object.assign(Object.assign({}, trigger), { key: triggerKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
-            inputCleaners: {},
+            inputCleaners,
             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));
+    const inputCleaners = Object.entries(inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
     return Object.assign(Object.assign({}, dataSource), { key: dataSourceKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
-            inputCleaners: {},
+            inputCleaners,
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
         }) });
 };

package/dist/serverTypes/index.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
-import { DataSourceType } from "../types";
+import { Instance, Customer, DataSourceType, DataSourceResultType } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
 }
+export { Instance } from "../types";
+export { Customer } from "../types";
 export interface Component {
     key: string;
     public?: boolean;
@@ -52,15 +54,8 @@ export interface ActionContext {
     webhookUrls: Record<string, string>;
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    customer: Customer;
+    instance: Instance;
 }
 declare type TriggerOptionChoice = "invalid" | "valid" | "required";
 export interface TriggerPayload {
@@ -79,15 +74,8 @@ export interface TriggerPayload {
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
     executionId: string;
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    customer: Customer;
+    instance: Instance;
 }
 interface HttpResponse {
     statusCode: number;
@@ -127,14 +115,19 @@ export interface Trigger {
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
 }
+export interface DataSourceContext {
+    logger: ActionLogger;
+    customer: Customer;
+    instance: Instance;
+}
 export declare type DataSourceResult = {
-    content: DataSourceType;
-    supplementalData: {
+    result: DataSourceResultType;
+    supplementalData?: {
         data: unknown;
         contentType: string;
     };
 };
-export declare type DataSourcePerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<DataSourceResult>;
+export declare type DataSourcePerformFunction = (context: DataSourceContext, params: Record<string, unknown>) => Promise<DataSourceResult>;
 export interface DataSource {
     key: string;
     display: DisplayDefinition & {
@@ -143,6 +136,7 @@ export interface DataSource {
     };
     inputs: Input[];
     perform: DataSourcePerformFunction;
+    dataSourceType: DataSourceType;
     examplePayload?: unknown;
 }
 export declare enum OAuth2Type {
@@ -214,4 +208,3 @@ export interface Input {
     model?: InputFieldChoice[];
     language?: string;
 }
-export {};

package/dist/serverTypes/perform.js

@@ -22,6 +22,10 @@ const cleanParams = (params, cleaners) => Object.entries(params).reduce((result,
 const createPerform = (performFn, { inputCleaners, errorHandler }) => {
     return (...args) => __awaiter(void 0, void 0, void 0, function* () {
         try {
+            if (args.length === 1) {
+                const [params] = args;
+                return yield performFn(cleanParams(params, inputCleaners));
+            }
             if (args.length === 2) {
                 const [context, params] = args;
                 return yield performFn(context, cleanParams(params, inputCleaners));

package/dist/testing.d.ts

@@ -4,7 +4,7 @@
  * 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, DataSourceResult } from "./serverTypes";
+import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn, DataSourceResult, DataSourceContext } from "./serverTypes";
 import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>) => ConnectionValue;
 /**
@@ -13,7 +13,7 @@ export declare const createConnection: <T extends ConnectionDefinition>({ key }:
  */
 export declare const loggerMock: () => ActionLogger;
 /**
- * The type of data returned by an `invoke()` function used for unit testing component actions.
+ * The type of data returned by an `invoke()` function used for unit testing component actions and triggers.
  */
 interface InvokeReturn<ReturnData> {
     result: ReturnData;
@@ -35,19 +35,36 @@ export declare const defaultTriggerPayload: () => TriggerPayload;
  */
 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.
+ * Invokes specified DataSourceDefinition perform function using supplied params.
+ * Accepts a generic type matching DataSourceResult as a convenience to avoid extra
+ * casting within test methods. Returns a DataSourceResult.
  */
-export declare const invokeDataSource: <TInputs extends Inputs, TReturn extends InvokeDataSourceResult<unknown>>({ perform }: DataSourceDefinition<TInputs, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
+export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType extends keyof {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string[];
+    schedule: {
+        value: string;
+    };
+    code: string;
+    credential: unknown;
+    boolean: boolean;
+    number: number;
+    connection: ConnectionDefinition;
+    objectSelection: import("./types").ObjectSelection;
+    objectFieldMap: import("./types").ObjectFieldMap;
+    jsonForm: import("./types").JSONForm;
+}>({ perform }: DataSourceDefinition<TInputs, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
+    private buildContext;
+    private buildParams;
     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>;
+    dataSource(key: string, params?: Record<string, unknown>, context?: Partial<DataSourceContext>): Promise<DataSourceResult>;
 }
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
@@ -55,6 +72,22 @@ 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>>;
+    invokeDataSource: <TInputs_2 extends Inputs, TDataSourceType extends keyof {
+        string: string;
+        date: string;
+        timestamp: string;
+        picklist: string[];
+        schedule: {
+            value: string;
+        };
+        code: string;
+        credential: unknown;
+        boolean: boolean;
+        number: number;
+        connection: ConnectionDefinition;
+        objectSelection: import("./types").ObjectSelection;
+        objectFieldMap: import("./types").ObjectFieldMap;
+        jsonForm: import("./types").JSONForm;
+    }>({ perform }: DataSourceDefinition<TInputs_2, TDataSourceType>, params: ActionInputParameters<TInputs_2>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 };
 export default _default;

package/dist/testing.js

@@ -37,7 +37,7 @@ const loggerMock = () => ({
     error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
-const baseContext = {
+const baseActionContext = {
     logger: (0, exports.loggerMock)(),
     instanceState: {},
     crossFlowState: {},
@@ -68,7 +68,7 @@ const baseContext = {
  * 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(Object.assign({}, baseContext), context);
+    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
     const result = yield perform(realizedContext, params);
     return {
         result,
@@ -120,7 +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(Object.assign({}, baseContext), context);
+    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const realizedParams = params || {};
     const result = yield perform(realizedContext, realizedPayload, realizedParams);
@@ -130,25 +130,40 @@ const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void
     };
 });
 exports.invokeTrigger = invokeTrigger;
+const baseDataSourceContext = {
+    logger: (0, exports.loggerMock)(),
+    customer: {
+        id: "customerId",
+        name: "Customer 1",
+        externalId: "1234",
+    },
+    instance: {
+        id: "instanceId",
+        name: "Instance 1",
+    },
+};
 /**
- * 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.
+ * Invokes specified DataSourceDefinition perform function using supplied params.
+ * Accepts a generic type matching DataSourceResult as a convenience to avoid extra
+ * casting within test methods. Returns a DataSourceResult.
  */
 const invokeDataSource = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseContext), context);
+    const realizedContext = Object.assign(Object.assign({}, baseDataSourceContext), context);
     const result = yield perform(realizedContext, params);
-    return {
-        result,
-        loggerMock: realizedContext.logger,
-    };
+    return result;
 });
 exports.invokeDataSource = invokeDataSource;
 class ComponentTestHarness {
     constructor(component) {
         this.component = component;
     }
+    buildContext(baseContext, context) {
+        return Object.assign(Object.assign({}, baseContext), context);
+    }
+    buildParams(inputs, params) {
+        const defaults = inputs.reduce((result, { key, default: defaultValue }) => (Object.assign(Object.assign({}, result), { [key]: `${defaultValue !== null && defaultValue !== void 0 ? defaultValue : ""}` })), {});
+        return Object.assign(Object.assign({}, defaults), params);
+    }
     connectionValue({ key }) {
         const { PRISMATIC_CONNECTION_VALUE: value } = process.env;
         if (!value) {
@@ -159,23 +174,20 @@ class ComponentTestHarness {
     }
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            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));
+            return trigger.perform(this.buildContext(baseActionContext, context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
         });
     }
     action(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign(Object.assign({}, baseContext), context);
             const action = this.component.actions[key];
-            return action.perform(realizedContext, Object.assign({}, params));
+            return action.perform(this.buildContext(baseActionContext, context), this.buildParams(action.inputs, 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));
+            return dataSource.perform(this.buildContext(baseDataSourceContext, context), this.buildParams(dataSource.inputs, params));
         });
     }
 }

package/dist/types/ActionPerformFunction.d.ts

@@ -1,4 +1,4 @@
-import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger } from ".";
+import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger, Instance, Customer } from ".";
 /** Definition of the function to perform when an Action is invoked. */
 export declare type ActionPerformFunction<TInputs extends Inputs, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
 /** Context provided to perform method containing helpers and contextual data */
@@ -21,15 +21,8 @@ export interface ActionContext {
     webhookApiKeys: Record<string, string[]>;
     /** The URL used to invoke the current execution */
     invokeUrl: string;
-    /** An object containing the ID, External ID and name of the customer the instance is deployed to */
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    /** An object containing the ID ad name of the currently running instance */
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    /** Contains attributes of the Customer for whom an Instance is being executed. */
+    customer: Customer;
+    /** Contains attributes of the Instance that is being executed. */
+    instance: Instance;
 }

package/dist/types/Customer.d.ts

@@ -0,0 +1,6 @@
+/** Contains attributes of the Customer for whom an Instance is being executed. */
+export interface Customer {
+    id: string;
+    externalId: string;
+    name: string;
+}

package/dist/types/DataSourceDefinition.d.ts

@@ -1,15 +1,19 @@
-import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceResult, DataSourceType } from ".";
+import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceType } 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<DataSourceType>> {
+export interface DataSourceDefinition<TInputs extends Inputs, TDataSourceType extends DataSourceType> {
     /** Defines how the Data Source is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
-    /** Function to perform when this Data Source is invoked. */
-    perform: DataSourcePerformFunction<TInputs, TDataSourceResult>;
+    /** Function to perform when this Data Source is invoked; fetches data from the data source. */
+    perform: DataSourcePerformFunction<TInputs, TDataSourceType>;
+    /** The type of data that this Data Source represents. */
+    dataSourceType: TDataSourceType;
     /** InputFields to present in the Prismatic interface for configuration of this Data Source. */
     inputs: TInputs;
     /** An example of the payload outputted by this Data Source. */
     examplePayload?: Awaited<ReturnType<this["perform"]>>;
+    /** Specifies the name of a Data Source in this Component which can provide additional details about the content for this Data Source, such as example values when selecting particular API object fields. */
+    detailDataSource?: string;
 }

package/dist/types/DataSourcePerformFunction.d.ts

@@ -1,3 +1,9 @@
-import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ActionContext } from ".";
+import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ActionLogger, Customer, Instance } from ".";
+/** Context provided to perform method containing helpers and contextual data */
+export interface DataSourceContext {
+    logger: ActionLogger;
+    customer: Customer;
+    instance: Instance;
+}
 /** Definition of the function to perform when a Data Source is invoked. */
-export declare type DataSourcePerformFunction<T extends Inputs, TResult extends DataSourceResult<DataSourceType>> = (context: ActionContext, params: ActionInputParameters<T>) => Promise<TResult>;
+export declare type DataSourcePerformFunction<TInputs extends Inputs, TDataSourceType extends DataSourceType> = (context: DataSourceContext, params: ActionInputParameters<TInputs>) => Promise<DataSourceResult<TDataSourceType>>;

package/dist/types/DataSourceResult.d.ts

@@ -1,10 +1,35 @@
+import { ConnectionDefinition } from "./ConnectionDefinition";
+import { ObjectSelection, ObjectFieldMap, JSONForm } from "./Inputs";
+/** The type of field that is appropriate for rendering the data that is the result of the data source perform function. */
+declare type DataSourceTypeMap = {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string[];
+    schedule: {
+        value: string;
+    };
+    code: string;
+    credential: unknown;
+    boolean: boolean;
+    number: number;
+    connection: ConnectionDefinition;
+    objectSelection: ObjectSelection;
+    objectFieldMap: ObjectFieldMap;
+    jsonForm: JSONForm;
+};
+export declare type DataSourceType = keyof DataSourceTypeMap;
+export declare type DataSourceResultType = DataSourceTypeMap[DataSourceType];
 /** Represents the result of a Data Source action. */
-export declare type DataSourceResult<ContentData> = {
-    /** The data that will be used as content. */
-    content: ContentData;
-    /** Additional data that may be useful for out-of-band processing at a later time. */
+export declare type DataSourceResult<TDataSourceType extends DataSourceType> = {
+    /** The resulting data that is returned from the data source. */
+    result: DataSourceTypeMap[TDataSourceType];
+    /** Additional data that may be useful for out-of-band processing at a later time.
+     *  NOTE: This is only available when the Data Source is called as part of fetching
+     *  contents for a Configuration Wizard Page. */
     supplementalData?: {
         data: unknown;
         contentType: string;
     };
 };
+export {};

package/dist/types/Inputs.d.ts

@@ -1,5 +1,33 @@
 import { ConditionalExpression } from "./conditional-logic";
-import { ObjectSelection, ObjectFieldMap } from "./DataSourceType";
+export declare type Element = {
+    key: string;
+    label?: string;
+};
+export declare type ObjectSelection = {
+    object: Element;
+    fields?: Element[];
+    defaultSelected?: boolean;
+}[];
+export declare type ObjectFieldMap = {
+    fields: {
+        field: Element;
+        mappedObject?: Element;
+        mappedField?: Element;
+        defaultObject?: Element;
+        defaultField?: Element;
+    }[];
+    options?: {
+        object: Element;
+        fields: Element[];
+    }[];
+};
+export declare type JSONForm = {
+    schema: Record<string, unknown>;
+    uiSchema: Record<string, unknown>;
+    data: unknown;
+};
+export declare type DynamicObjectSelection = string;
+export declare type DynamicFieldSelection = string;
 /** InputField type enumeration. */
 export declare type InputFieldType = InputFieldDefinition["type"];
 export declare const InputFieldDefaultMap: Record<InputFieldType, string | undefined>;
@@ -7,7 +35,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 | ObjectSelectionInputField | ObjectFieldMapInputField;
+export declare type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField | ObjectSelectionInputField | ObjectFieldMapInputField | JSONFormInputField | DynamicObjectSelectionInputField | DynamicFieldSelectionInputField;
 export declare type InputCleanFunction<TValue, TResult = TValue> = (value: TValue) => TResult;
 interface BaseInputField {
     /** Interface label of the InputField. */
@@ -136,7 +164,7 @@ export interface Connection {
 /** Defines attributes of an ObjectSelectionInputField. */
 export interface ObjectSelectionInputField extends BaseInputField {
     /** Data type the InputField will collect. */
-    type: "objectselection";
+    type: "objectSelection";
     /** Collection type of the InputField */
     collection?: InputFieldCollection;
     /** Default value for this field. */
@@ -147,7 +175,7 @@ export interface ObjectSelectionInputField extends BaseInputField {
 /** Defines attributes of an ObjectFieldMapInputField. */
 export interface ObjectFieldMapInputField extends BaseInputField {
     /** Data type the InputField will collect. */
-    type: "objectfieldmap";
+    type: "objectFieldMap";
     /** Collection type of the InputField */
     collection?: InputFieldCollection;
     /** Default value for this field. */
@@ -155,6 +183,39 @@ export interface ObjectFieldMapInputField extends BaseInputField {
     /** Clean function */
     clean?: InputCleanFunction<NonNullable<this["default"]>>;
 }
+/** Defines attributes of a JSONFormInputField. */
+export interface JSONFormInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "jsonForm";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: JSONForm;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of a DynamicObjectSelectionInputField */
+export interface DynamicObjectSelectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "dynamicObjectSelection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** Clean function */
+    clean?: InputCleanFunction<NonNullable<this["default"]>>;
+}
+/** Defines attributes of a SelectedFieldInputField */
+export interface DynamicFieldSelectionInputField extends BaseInputField {
+    /** Data type the InputField will collect. */
+    type: "dynamicFieldSelection";
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Default value for this field. */
+    default?: unknown;
+    /** 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,6 +10,9 @@ exports.InputFieldDefaultMap = {
     code: "",
     conditional: undefined,
     connection: undefined,
-    objectselection: undefined,
-    objectfieldmap: undefined,
+    objectSelection: undefined,
+    objectFieldMap: undefined,
+    jsonForm: undefined,
+    dynamicObjectSelection: "",
+    dynamicFieldSelection: "",
 };

package/dist/types/Instance.d.ts

@@ -0,0 +1,5 @@
+/** Contains attributes of the Instance that is being executed. */
+export interface Instance {
+    id: string;
+    name: string;
+}

package/dist/types/Instance.js

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

package/dist/types/TriggerPayload.d.ts

@@ -1,3 +1,4 @@
+import { Instance, Customer } from ".";
 /** Represents a Trigger Payload, which is data passed into a Trigger to invoke an Integration execution. */
 export interface TriggerPayload {
     headers: {
@@ -27,13 +28,8 @@ export interface TriggerPayload {
     /** The URL that was used to invoke the execution. */
     invokeUrl: string;
     executionId: string;
-    customer: {
-        id: string | null;
-        externalId: string | null;
-        name: string | null;
-    };
-    instance: {
-        id: string | null;
-        name: string | null;
-    };
+    /** Contains attributes of the Customer for whom an Instance is being executed. */
+    customer: Customer;
+    /** Contains attributes of the Instance that is being executed. */
+    instance: Instance;
 }

package/dist/types/index.d.ts

@@ -21,4 +21,6 @@ export * from "./TriggerPayload";
 export * from "./DataSourceDefinition";
 export * from "./DataSourcePerformFunction";
 export * from "./DataSourceResult";
-export * from "./DataSourceType";
+export * from "./Instance";
+export * from "./Customer";
+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);
@@ -37,4 +50,6 @@ __exportStar(require("./TriggerPayload"), exports);
 __exportStar(require("./DataSourceDefinition"), exports);
 __exportStar(require("./DataSourcePerformFunction"), exports);
 __exportStar(require("./DataSourceResult"), exports);
-__exportStar(require("./DataSourceType"), exports);
+__exportStar(require("./Instance"), exports);
+__exportStar(require("./Customer"), 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, ObjectSelection, ObjectFieldMap } from "./types";
+import { KeyValuePair, DataPayload, ObjectSelection, ObjectFieldMap, JSONForm, ConnectionDefinition } from "./types";
 /**
  * This function returns a lower cased version of the headers passed to it.
  *
@@ -31,6 +31,7 @@ declare const _default: {
         toBufferDataPayload: (value: unknown) => DataPayload;
         isData: (value: unknown) => boolean;
         toData: (value: unknown) => DataPayload;
+        isString: (value: unknown) => value is string;
         toString: (value: unknown, defaultValue?: string) => string;
         keyValPairListToObject: <TValue = unknown>(kvpList: KeyValuePair<unknown>[], valueConverter?: ((value: unknown) => TValue) | undefined) => Record<string, TValue>;
         isJSON: (value: string) => boolean;
@@ -40,6 +41,11 @@ declare const _default: {
         toObjectSelection: (value: unknown) => ObjectSelection;
         isObjectFieldMap: (value: unknown) => value is ObjectFieldMap;
         toObjectFieldMap: (value: unknown) => ObjectFieldMap;
+        isJSONForm: (value: unknown) => value is JSONForm;
+        toJSONForm: (value: unknown) => JSONForm;
+        isPicklist: (value: unknown) => boolean;
+        isSchedule: (value: unknown) => boolean;
+        isConnection: (value: unknown) => value is ConnectionDefinition;
     };
     docs: {
         formatJsonExample: (input: unknown) => string;

package/dist/util.js

@@ -25,25 +25,11 @@ const isObjectWithTruthyKeys = (value, keys) => {
  * @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;
+    if (typeof value === "string" && isJSON(value)) {
+        return isObjectSelection(JSON.parse(value));
     }
-    return true;
+    return (Array.isArray(value) &&
+        value.every((item) => isObjectWithTruthyKeys(item, ["object"])));
 };
 /**
  * This function coerces a provided value into an ObjectSelection if possible.
@@ -51,33 +37,31 @@ const isObjectSelection = (value) => {
  * @returns This function returns the the value as an ObjectSelection if possible.
  */
 const toObjectSelection = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toObjectSelection(JSON.parse(value));
+    }
     if (isObjectSelection(value)) {
         return value;
     }
-    throw new Error(`Value '${value}' cannot be coerced to ObjectSelection.`);
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(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;
-            }
-        }
+    if (typeof value === "string" && isJSON(value)) {
+        return isObjectFieldMap(JSON.parse(value));
     }
-    else {
-        return false;
+    if (Boolean(value) && typeof value === "object") {
+        const { fields } = value;
+        return (Array.isArray(fields) &&
+            fields.every((item) => isObjectWithTruthyKeys(item, ["field"]) &&
+                isObjectWithTruthyKeys(item === null || item === void 0 ? void 0 : item.field, [
+                    "key",
+                ])));
     }
-    return true;
+    return false;
 };
 /**
  * This function coerces a provided value into an ObjectFieldMap if possible.
@@ -85,10 +69,37 @@ const isObjectFieldMap = (value) => {
  * @returns This function returns the the value as an ObjectFieldMap if possible.
  */
 const toObjectFieldMap = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toObjectFieldMap(JSON.parse(value));
+    }
     if (isObjectFieldMap(value)) {
         return value;
     }
-    throw new Error(`Value '${value}' cannot be coerced to ObjectFieldMap.`);
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to ObjectFieldMap.`);
+};
+/**
+ * @param value The value to test
+ * @returns This function returns true if the type of `value` is a JSONForm, or false otherwise.
+ */
+const isJSONForm = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isJSONForm(JSON.parse(value));
+    }
+    return isObjectWithTruthyKeys(value, ["schema", "uiSchema", "data"]);
+};
+/**
+ * This function coerces a provided value into a JSONForm if possible.
+ * @param value The value to coerce to JSONForm.
+ * @returns This function returns the the value as a JSONForm if possible.
+ */
+const toJSONForm = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toJSONForm(JSON.parse(value));
+    }
+    if (isJSONForm(value)) {
+        return value;
+    }
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to JSONForm.`);
 };
 /**
  * Determine if a variable is a boolean (true or false).
@@ -262,6 +273,25 @@ const toDate = (value) => {
  * @returns This function returns true if `value` is a valid URL, and false otherwise.
  */
 const isUrl = (value) => (0, valid_url_1.isWebUri)(value) !== undefined;
+/**
+ * This function checks if value is a valid picklist.
+ *
+ * - `util.types.isPicklist(["value", new String("value")])` will return `true`.
+ *
+ * @param value The variable to test.
+ * @returns This function returns true if `value` is a valid picklist.
+ */
+const isPicklist = (value) => Array.isArray(value) && value.every(isString);
+/**
+ * This function checks if value is a valid schedule.
+ *
+ * - `util.types.isSchedule({value: "00 00 * * 2,3"})` will return `true`.
+ * - `util.types.isSchedule({value: "00 00 * * 2,3", scheduleType: "week", timeZone: "America/Chicago"})` will return `true`.
+ *
+ * @param value The variable to test.
+ * @returns This function returns true if `value` is a valid schedule.
+ */
+const isSchedule = (value) => isObjectWithTruthyKeys(value, ["value"]);
 /**
  * This function helps to transform key-value lists to objects.
  * This is useful for transforming inputs that are key-value collections into objects.
@@ -355,6 +385,13 @@ const toData = (value) => toBufferDataPayload(value);
  * @returns This function returns a code block that can be used for documentation.
  */
 const formatJsonExample = (input) => ["```json", JSON.stringify(input, undefined, 2), "```"].join("\n");
+/**
+ * This function checks if value is a string.
+ * `util.types.isString("value")` and `util.types.isString(new String("value"))` return true.
+ * @param value The variable to test.
+ * @returns This function returns true or false, depending on if `value` is a string.
+ */
+const isString = (value) => typeof value === "string" || value instanceof String;
 /**
  * This function converts a `value` to a string.
  * If `value` is undefined or an empty string, an optional `defaultValue` can be returned.
@@ -368,6 +405,31 @@ const formatJsonExample = (input) => ["```json", JSON.stringify(input, undefined
  * @returns This function returns the stringified version fo `value`, or `defaultValue` in the case that `value` is undefined or an empty string.
  */
 const toString = (value, defaultValue = "") => `${value !== null && value !== void 0 ? value : defaultValue}`;
+/**
+ * This function checks if value is a valid connection.
+ * @param value The variable to test.
+ * @returns This function returns true or false, depending on if `value` is a valid connection.
+ */
+const isConnection = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isConnection(JSON.parse(value));
+    }
+    if (Boolean(value) && typeof value === "object") {
+        const { inputs } = value;
+        if (isObjectWithTruthyKeys(value, ["key", "label", "oauth2Type"])) {
+            return (isObjectWithTruthyKeys(inputs, [
+                "authorizeUrl",
+                "tokenUrl",
+                "clientId",
+                "clientSecret",
+            ]) ||
+                isObjectWithTruthyKeys(inputs, ["tokenUrl", "clientId", "clientSecret"]));
+        }
+        return (isObjectWithTruthyKeys(value, ["key", "label"]) &&
+            typeof inputs === "object");
+    }
+    return false;
+};
 /**
  * This function returns true if `value` resembles the shape of JSON, and false otherwise.
  *
@@ -427,6 +489,7 @@ exports.default = {
         toBufferDataPayload,
         isData,
         toData,
+        isString,
         toString,
         keyValPairListToObject,
         isJSON,
@@ -436,6 +499,11 @@ exports.default = {
         toObjectSelection,
         isObjectFieldMap,
         toObjectFieldMap,
+        isJSONForm,
+        toJSONForm,
+        isPicklist,
+        isSchedule,
+        isConnection,
     },
     docs: {
         formatJsonExample,

package/package.json

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

package/dist/types/DataSourceType.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" />
-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;
-    };
-}[];
-export declare type DataSourceType = ObjectSelection | ObjectFieldMap | Buffer | boolean | number | string | Record<string, unknown> | unknown[] | unknown;