@prismatic-io/spectral 7.0.9-pre → 7.0.12-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, 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,5 +1,5 @@
 /// <reference types="node" />
-import { DataSourceResultType, DataSourceResultFieldType, Instance, Customer } from "../types";
+import { Instance, Customer, DataSourceType, DataSourceResultType } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -131,7 +131,7 @@ export interface DataSource {
     };
     inputs: Input[];
     perform: DataSourcePerformFunction;
-    resultFieldType: DataSourceResultFieldType;
+    dataSourceType: DataSourceType;
     examplePayload?: unknown;
 }
 export declare enum OAuth2Type {

package/dist/testing.d.ts

@@ -5,7 +5,7 @@
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
 import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn, DataSourceResult } from "./serverTypes";
-import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult } from "./types";
+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.
@@ -39,7 +39,23 @@ export declare const invokeTrigger: <TInputs extends Inputs, TAllowsBranching ex
  * 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 DataSourceResult>({ perform }: DataSourceDefinition<TInputs, TReturn>, params: ActionInputParameters<TInputs>) => Promise<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>) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
@@ -54,6 +70,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 DataSourceResult>({ perform }: DataSourceDefinition<TInputs_2, TReturn_1>, params: ActionInputParameters<TInputs_2>) => Promise<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>) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 };
 export default _default;

package/dist/types/DataSourceDefinition.d.ts

@@ -1,15 +1,15 @@
-import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceResult, DataSourceResultType, DataSourceResultFieldType } 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<DataSourceResultType>> {
+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>;
-    /** Field type of the data produced by the data source perform function. */
-    resultFieldType: DataSourceResultFieldType;
+    /** 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. */

package/dist/types/DataSourcePerformFunction.d.ts

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

package/dist/types/DataSourceResult.d.ts

@@ -1,13 +1,29 @@
-/// <reference types="node" />
+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. */
-export declare type DataSourceResultFieldType = "string" | "date" | "timestamp" | "picklist" | "schedule" | "code" | "credential" | "boolean" | "number" | "connection" | "objectSelection" | "objectFieldMap" | "jsonForm";
-/** The actual data type of the data that is the result of the data source perform function. */
-export declare type DataSourceResultType = ObjectSelection | ObjectFieldMap | JSONForm | Buffer | boolean | number | string | Record<string, unknown> | unknown[] | unknown;
+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<TDataSourceResultType> = {
+export declare type DataSourceResult<TDataSourceType extends DataSourceType> = {
     /** The resulting data that is returned from the data source. */
-    result: TDataSourceResultType;
+    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. */
@@ -16,3 +32,4 @@ export declare type DataSourceResult<TDataSourceResultType> = {
         contentType: string;
     };
 };
+export {};

package/dist/types/Inputs.d.ts

@@ -1,27 +1,26 @@
 import { ConditionalExpression } from "./conditional-logic";
-export declare type ObjectSelection = {
+export declare type Element = {
     key: string;
     label?: string;
-    selected?: boolean;
-    fields?: {
-        key: string;
-        label?: string;
-    }[];
+};
+export declare type ObjectSelection = {
+    object: Element;
+    fields?: Element[];
+    defaultSelected?: boolean;
 }[];
 export declare type ObjectFieldMap = {
-    key: string;
-    label?: string;
-    value: {
-        objectKey: string;
-        objectLabel?: string;
-        fieldKey: string;
-        fieldLabel?: string;
-    };
-    defaultValue?: {
-        objectKey: string;
-        fieldKey: string;
-    };
-}[];
+    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>;

package/package.json

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