@prismatic-io/spectral 7.0.11-pre → 7.0.14-pre

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

@@ -115,6 +115,11 @@ export interface Trigger {
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
 }
+export interface DataSourceContext {
+    logger: ActionLogger;
+    customer: Customer;
+    instance: Instance;
+}
 export declare type DataSourceResult = {
     result: DataSourceResultType;
     supplementalData?: {
@@ -122,7 +127,7 @@ export declare type DataSourceResult = {
         contentType: string;
     };
 };
-export declare type DataSourcePerformFunction = (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 & {

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;
 /**
@@ -55,14 +55,16 @@ export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType
     objectSelection: import("./types").ObjectSelection;
     objectFieldMap: import("./types").ObjectFieldMap;
     jsonForm: import("./types").JSONForm;
-}>({ perform }: DataSourceDefinition<TInputs, TDataSourceType>, params: ActionInputParameters<TInputs>) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+}>({ 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>): 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: {
@@ -86,6 +88,6 @@ declare const _default: {
         objectSelection: import("./types").ObjectSelection;
         objectFieldMap: import("./types").ObjectFieldMap;
         jsonForm: import("./types").JSONForm;
-    }>({ perform }: DataSourceDefinition<TInputs_2, TDataSourceType>, params: ActionInputParameters<TInputs_2>) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+    }>({ 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,13 +130,26 @@ 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.
  * Accepts a generic type matching DataSourceResult as a convenience to avoid extra
  * casting within test methods. Returns a DataSourceResult.
  */
-const invokeDataSource = ({ perform }, params) => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield perform(params);
+const invokeDataSource = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = Object.assign(Object.assign({}, baseDataSourceContext), context);
+    const result = yield perform(realizedContext, params);
     return result;
 });
 exports.invokeDataSource = invokeDataSource;
@@ -144,6 +157,13 @@ 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) {
@@ -154,22 +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) {
+    dataSource(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const dataSource = this.component.dataSources[key];
-            return dataSource.perform(Object.assign({}, params));
+            return dataSource.perform(this.buildContext(baseDataSourceContext, context), this.buildParams(dataSource.inputs, params));
         });
     }
 }

package/dist/types/DataSourcePerformFunction.d.ts

@@ -1,3 +1,9 @@
-import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters } 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<TInputs extends Inputs, TDataSourceType extends DataSourceType> = (params: ActionInputParameters<TInputs>) => Promise<DataSourceResult<TDataSourceType>>;
+export declare type DataSourcePerformFunction<TInputs extends Inputs, TDataSourceType extends DataSourceType> = (context: DataSourceContext, params: ActionInputParameters<TInputs>) => Promise<DataSourceResult<TDataSourceType>>;

package/dist/types/Inputs.d.ts

@@ -16,7 +16,7 @@ export declare type ObjectFieldMap = {
         defaultObject?: Element;
         defaultField?: Element;
     }[];
-    options: {
+    options?: {
         object: Element;
         fields: Element[];
     }[];

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"])) {
-                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,16 +69,22 @@ 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"]);
 };
 /**
@@ -103,10 +93,13 @@ const isJSONForm = (value) => {
  * @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 '${value}' cannot be coerced to JSONForm.`);
+    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).

package/package.json

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