@prismatic-io/spectral 10.3.9 → 10.3.10

package/dist/serverTypes/context.d.ts

@@ -0,0 +1,4 @@
+import { ActionContext as ServerActionContext } from ".";
+import { ActionContext, DebugContext } from "../types";
+export declare function createDebugContext(context: ServerActionContext): DebugContext;
+export declare function logDebugResults(context: ActionContext): void;

package/dist/serverTypes/context.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDebugContext = createDebugContext;
+exports.logDebugResults = logDebugResults;
+const node_process_1 = require("node:process");
+const node_perf_hooks_1 = require("node:perf_hooks");
+function createDebugContext(context) {
+    const globalDebug = Boolean(context.globalDebug);
+    return {
+        enabled: globalDebug,
+        timeElapsed: {
+            mark: (actionContext, label) => {
+                if (globalDebug) {
+                    actionContext.debug.results.timeElapsed.marks[label] = node_perf_hooks_1.performance.now();
+                }
+            },
+            measure: (actionContext, label, marks) => {
+                if (globalDebug) {
+                    actionContext.debug.results.timeElapsed.measurements[label] = {
+                        marks,
+                        duration: actionContext.debug.results.timeElapsed.marks[marks.end] -
+                            actionContext.debug.results.timeElapsed.marks[marks.start],
+                    };
+                }
+            },
+        },
+        memoryUsage: (actionContext, label, showDetail) => {
+            if (globalDebug) {
+                // @ts-expect-error: memoryUsage.rss() is documented but not typed
+                const usage = showDetail ? (0, node_process_1.memoryUsage)() : node_process_1.memoryUsage.rss();
+                actionContext.debug.results.memoryUsage.push({
+                    mark: label,
+                    rss: typeof usage === "number" ? usage / 1000000 : usage.rss / 1000000,
+                    detail: typeof usage === "number" ? undefined : usage,
+                });
+            }
+        },
+        results: {
+            timeElapsed: { marks: {}, measurements: {} },
+            memoryUsage: [],
+            allowedMemory: Number(context.runnerAllocatedMemoryMb),
+        },
+    };
+}
+function logDebugResults(context) {
+    if (context.debug.enabled) {
+        context.logger.metric(context.debug.results);
+    }
+}

package/dist/serverTypes/convertIntegration.js

@@ -23,6 +23,7 @@ const convertComponent_1 = require("./convertComponent");
 const integration_1 = require("./integration");
 const merge_1 = __importDefault(require("lodash/merge"));
 const perform_1 = require("./perform");
+const context_1 = require("./context");
 const convertIntegration = (definition) => {
     var _a, _b, _c;
     // Generate a unique reference key that will be used to reference the
@@ -518,7 +519,7 @@ const generateOnInstanceWrapperFn = (componentRef, onTrigger, eventName, customF
         : customFn;
     return onInstanceFn;
 };
-const convertOnExecution = (onExecution, componentRegistry) => (context, params) => {
+const convertOnExecution = (onExecution, componentRegistry) => (context, params) => __awaiter(void 0, void 0, void 0, function* () {
     // @ts-expect-error _components isn't part of the public API
     const { _components } = context;
     const invoke = _components.invoke;
@@ -551,8 +552,11 @@ const convertOnExecution = (onExecution, componentRegistry) => (context, params)
         }, {});
         return Object.assign(Object.assign({}, accumulator), { [registryComponentKey]: componentActions });
     }, {});
-    return onExecution(Object.assign(Object.assign({}, context), { components: componentMethods, invokeFlow: (0, perform_1.createInvokeFlow)(context, { isCNI: true }) }), params);
-};
+    const actionContext = Object.assign(Object.assign({}, context), { debug: (0, context_1.createDebugContext)(context), components: componentMethods, invokeFlow: (0, perform_1.createInvokeFlow)(context, { isCNI: true }) });
+    const result = yield onExecution(actionContext, params);
+    (0, context_1.logDebugResults)(actionContext);
+    return result;
+});
 /** Creates the structure necessary to import a Component as part of a
  *  Code Native integration. */
 const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], componentRegistry = {} }, referenceKey, configVars) => {

package/dist/serverTypes/index.d.ts

@@ -1,4 +1,4 @@
-import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest, FlowInvoker, ExecutionFrame } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest, FlowInvoker, ExecutionFrame, DebugContext } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -54,11 +54,6 @@ export type ActionContext<TConfigVars extends ConfigVarResultCollection = Config
     executionState: Record<string, unknown>;
     integrationState: Record<string, unknown>;
     configVars: TConfigVars;
-    components: {
-        [K in keyof TComponentActions]: {
-            [A in keyof TComponentActions[K]]: TComponentActions[K][A]["perform"];
-        };
-    };
     stepId: string;
     executionId: string;
     webhookUrls: Record<string, string>;
@@ -70,9 +65,16 @@ export type ActionContext<TConfigVars extends ConfigVarResultCollection = Config
     integration: IntegrationAttributes;
     flow: FlowAttributes;
     startedAt: string;
-    invokeFlow: FlowInvoker<TFlows>;
     executionFrame: ExecutionFrame;
-    globalDebug: boolean;
+    globalDebug?: boolean;
+    runnerAllocatedMemoryMb?: number;
+    components: {
+        [K in keyof TComponentActions]: {
+            [A in keyof TComponentActions[K]]: TComponentActions[K][A]["perform"];
+        };
+    };
+    invokeFlow: FlowInvoker<TFlows>;
+    debug: DebugContext;
 };
 type TriggerOptionChoice = "invalid" | "valid" | "required";
 export interface TriggerPayload {

package/dist/serverTypes/perform.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPollingPerform = exports.createPerform = exports.createInvokeFlow = exports.cleanParams = void 0;
 const axios_1 = __importDefault(require("axios"));
 const uniq_1 = __importDefault(require("lodash/uniq"));
+const context_1 = require("./context");
 const cleanParams = (params, cleaners) => {
     const keys = (0, uniq_1.default)([...Object.keys(params), ...Object.keys(cleaners)]);
     return keys.reduce((result, key) => {
@@ -63,10 +64,16 @@ const createPerform = (performFn, { inputCleaners, errorHandler }) => {
             }
             if (args.length === 2) {
                 const [context, params] = args;
-                return yield performFn(Object.assign(Object.assign({}, context), { invokeFlow: (0, exports.createInvokeFlow)(context) }), (0, exports.cleanParams)(params, inputCleaners));
+                const actionContext = Object.assign(Object.assign({}, context), { debug: (0, context_1.createDebugContext)(context), invokeFlow: (0, exports.createInvokeFlow)(context) });
+                const result = yield performFn(actionContext, (0, exports.cleanParams)(params, inputCleaners));
+                (0, context_1.logDebugResults)(actionContext);
+                return result;
             }
             const [context, payload, params] = args;
-            return yield performFn(Object.assign(Object.assign({}, context), { invokeFlow: (0, exports.createInvokeFlow)(context) }), payload, (0, exports.cleanParams)(params, inputCleaners));
+            const actionContext = Object.assign(Object.assign({}, context), { debug: (0, context_1.createDebugContext)(context), invokeFlow: (0, exports.createInvokeFlow)(context) });
+            const result = yield performFn(actionContext, payload, (0, exports.cleanParams)(params, inputCleaners));
+            (0, context_1.logDebugResults)(actionContext);
+            return result;
         }
         catch (error) {
             throw errorHandler ? errorHandler(error) : error;

package/dist/testing.js

@@ -113,7 +113,19 @@ const createActionContext = (context) => {
             executionStartedAt: "",
             stepName: "some-step",
             loopPath: "",
-        }, globalDebug: false }, context);
+        }, debug: {
+            enabled: false,
+            timeElapsed: {
+                mark: (context, label) => { },
+                measure: (context, label, marks) => { },
+            },
+            memoryUsage: (context, label, showDetail) => { },
+            results: {
+                timeElapsed: { marks: {}, measurements: {} },
+                memoryUsage: [],
+                allowedMemory: 1024,
+            },
+        } }, context);
 };
 const createDataSourceContext = (context) => {
     return Object.assign({ logger: (0, exports.loggerMock)(), configVars: {}, customer: {

package/dist/types/ActionPerformFunction.d.ts

@@ -10,6 +10,54 @@ interface StandardLineage {
 interface CustomLineage {
     customSource: string;
 }
+export interface DebugContext {
+    /** READ-ONLY: Denotes whether code should be executed in debug mode. */
+    enabled: boolean;
+    /** Helper methods for measuring how long a process takes between marks. Only runs if debug.enabled is true. */
+    timeElapsed: {
+        /** Creates a mark for measuring time in your process. */
+        mark: (context: ActionContext, label: string) => void;
+        /** Measures the time spent between two marks. The label should be a unique descriptor of this duration. */
+        measure: (context: ActionContext, label: string, marks: {
+            start: string;
+            end: string;
+        }) => void;
+    };
+    /** Measures memory usage up until that point in the process. showDetail will run slower but show the full output of process.memoryUsage().
+     * Only runs if debug.enabled is true. */
+    memoryUsage: (context: ActionContext, label: string, showDetail?: boolean) => void;
+    /** Resulting debug measurements that can be logged or saved. */
+    results: DebugResult;
+}
+interface DebugResult {
+    /** Resulting data about time measurements. */
+    timeElapsed: {
+        /** The set of recorded marks and their measured start times. */
+        marks: Record<string, number>;
+        /** The set of measured durations based on the difference in marked times. */
+        measurements: Record<string, {
+            marks: {
+                start: string;
+                end: string;
+            };
+            duration: number;
+        }>;
+    };
+    /** Memory limit in MB */
+    allowedMemory: number;
+    /** Resulting data bout memory usage. */
+    memoryUsage: Array<{
+        mark: string;
+        rss: number;
+        detail?: {
+            rss: number;
+            heapTotal: number;
+            heapUsed: number;
+            external: number;
+            arrayBuffers: number;
+        };
+    }>;
+}
 export type ExecutionFrame = ({
     invokedByExecutionJWT: string;
     invokedByExecutionStartedAt: string;
@@ -19,7 +67,7 @@ export type ExecutionFrame = ({
 } & CustomLineage);
 export type FlowInvoker<TFlows extends Readonly<string[]> | undefined> = (flowName: TFlows extends Readonly<string[]> ? TFlows[number] : string, data?: Record<string, unknown>, config?: AxiosRequestConfig<any>, source?: string) => Promise<AxiosResponse<any, any>>;
 /** Definition of the function to perform when an Action is invoked. */
-export type ActionPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]>, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars, TComponentActions>, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
+export type ActionPerformFunction<TInputs extends Inputs = Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>, TAllowsBranching extends boolean | undefined = undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown> = ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars, TComponentActions>, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
 /** Context provided to perform method containing helpers and contextual data */
 export type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>, TFlows extends string[] = string[]> = {
     /** Logger for permanent logging; console calls are also captured */
@@ -62,11 +110,11 @@ export type ActionContext<TConfigVars extends ConfigVarResultCollection = Config
     flow: FlowAttributes;
     /** The time in UTC that execution started. */
     startedAt: string;
-    /** Function to invoke an execution of another flow.. */
+    /** Function to invoke an execution of another flow. */
     invokeFlow: FlowInvoker<TFlows>;
     /** Reference to the current execution and, when applicable, the current step. */
     executionFrame: ExecutionFrame;
-    /** Denotes whether code should be executed in debug mode. */
-    globalDebug: boolean;
+    /** Contains methods, flags, and data to support debug modes. */
+    debug: DebugContext;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "10.3.9",
+  "version": "10.3.10",
   "description": "Utility library for building Prismatic connectors and code-native integrations",
   "keywords": ["prismatic"],
   "main": "dist/index.js",