@prismatic-io/spectral 10.3.0 → 10.3.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Prismatic LLC.
+Copyright (c) 2024 Prismatic LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,6 +1,9 @@
-# @prismatic-io/spectral
+<div align="center">
+  <img src="https://prismatic.io/favicon-48x48.png" />
+  <h1>@prismatic-io/spectral</h1>
+</div>
 
-This repository contains code for Prismatic's TypeScript library, `spectral`, which is used to build custom Prismatic components.
+This repository contains code for Prismatic's TypeScript library, `spectral`, which is used to build custom Prismatic connectors and code-native integrations.
 
 ## Using Spectral
 
@@ -10,47 +13,41 @@ To install spectral, run:
 npm install @prismatic-io/spectral
 ```
 
-Please see our [documentation](https://prismatic.io/docs/custom-components/writing-custom-components) on writing and publishing custom components for Prismatic's platform.
+Please see our [documentation](https://prismatic.io/docs/custom-connectors/) on writing and publishing custom connectors for Prismatic's platform.
 
 ## What is Prismatic?
 
-Prismatic is the integration platform for B2B software companies. It's the quickest way to build integrations to the other apps your customers use and to add a native integration marketplace to your product.
+Prismatic is the leading embedded iPaaS, enabling B2B SaaS teams to ship product integrations faster and with less dev time. The only embedded iPaaS that empowers both developers and non-developers with tools for the complete integration lifecycle, Prismatic includes low-code and code-native building options, deployment and management tooling, and self-serve customer tools.
 
-Prismatic significantly reduces overall integration effort and enables non-dev teams to take on more of the integration workload, so that you can deliver integrations faster and spend more time on core product innovation.
+Prismatic's unparalleled versatility lets teams deliver any integration from simple to complex in one powerful platform. SaaS companies worldwide, from startups to Fortune 500s, trust Prismatic to help connect their products to the other products their customers use.
 
 With Prismatic, you can:
 
-- Build reusable [integrations](https://prismatic.io/docs/integrations) in a low-code integration designer that's tailored for your product
-- Use [pre-built components](https://prismatic.io/docs/components/component-catalog) to handle most of your integrations' functionality, and write [custom components](https://prismatic.io/docs/custom-components/writing-custom-components) when needed
-- Quickly add an [integration marketplace](https://prismatic.io/docs/integration-marketplace) to your product so customers can explore, activate, and monitor integrations
-- Easily deploy customer-specific integration [instances](https://prismatic.io/docs/instances) with unique configurations and connections
-- Provide better support with tools like [logging](https://prismatic.io/docs/logging) and [alerting](https://prismatic.io/docs/monitoring-and-alerting)
-- Run your integrations in a purpose-built environment designed for security and scalability
-- Use powerful dev tools to mold the platform to your product, industry, and the way you build software
+- Build [integrations](https://prismatic.io/docs/integrations/) using our [intuitive low-code designer](https://prismatic.io/docs/integrations/low-code-integration-designer/) or [code-native](https://prismatic.io/docs/integrations/code-native/) approach in your preferred IDE
+- Leverage pre-built [connectors](https://prismatic.io/docs/components/) for common integration tasks, or develop custom connectors using our TypeScript SDK
+- Embed a native [integration marketplace](https://prismatic.io/docs/embed/) in your product for customer self-service
+- Configure and deploy customer-specific integration instances with powerful configuration tools
+- Support customers efficiently with comprehensive [logging, monitoring, and alerting](https://prismatic.io/docs/monitor-instances/)
+- Run integrations in a secure, scalable infrastructure designed for B2B SaaS
+- Customize the platform to fit your product, industry, and development workflows
 
 ## Who uses Prismatic?
 
-Prismatic is for B2B (business-to-business) software companies, meaning software companies that provide applications used by businesses. It's a good fit for products/teams ranging from early-stage and growing SaaS startups to large, established software companies looking to improve the way they do integrations.
+Prismatic is built for B2B software companies that need to provide integrations to their customers. Whether you're a growing SaaS startup or an established enterprise, Prismatic's platform scales with your integration needs.
 
-Many B2B software teams serve customers in niche vertical markets, and we designed Prismatic with that in mind. We provide powerful and flexible tools so you can build exactly the integrations your customers need, no matter who your customers are, no matter what systems you need to connect to, no matter how "non-standard" your integration scenario.
+Our platform is particularly powerful for teams serving specialized vertical markets. We provide the flexibility and tools to build exactly the integrations your customers need, regardless of the systems you're connecting to or how unique your integration requirements may be.
 
 ## What kind of integrations can you build using Prismatic?
 
-Prismatic supports integrations ranging from simple and standard to complex, bespoke, and vertical-specific.
-Teams use it to build integrations between applications of all kinds, SaaS or legacy, with or without a modern API, regardless of protocol or data format.
-Here are some example use cases:
+Prismatic supports integrations of any complexity - from simple data syncs to sophisticated, industry-specific solutions. Teams use it to build integrations between any type of system, whether modern SaaS or legacy with standard or custom protocols. Here are some example use cases:
 
-- Use job data from your system to create invoices in your customers' ERP.
-- Import and process data from third-party forms that vary significantly from customer to customer.
-- Email activity summary reports with parameters and intervals defined on a per-customer basis.
+- Connect your product with customers' ERPs, CRMs, and other business systems
+- Process data from multiple sources with customer-specific transformation requirements
+- Automate workflows with customizable triggers, actions, and schedules
+- Handle complex authentication flows and data mapping scenarios
 
-For information on the Prismatic platform, check out our [website](https://prismatic.io) and [docs](https://prismatic.io/docs).
-
-## Building Spectral Locally
-
-To build spectral locally, you'll need `yarn` and `node` installed.
-Run `yarn build` to build the package, or `yarn pack` to build a tarball that can be used in custom components for testing changes to spectral.
+For information on the Prismatic platform, check out our [website](https://prismatic.io/) and [docs](https://prismatic.io/docs/).
 
 ## License
 
-This repository is [MIT licensed](./LICENSE).
+This repository is MIT licensed.

package/dist/serverTypes/convertIntegration.js

@@ -20,6 +20,7 @@ const types_1 = require("../types");
 const convertComponent_1 = require("./convertComponent");
 const integration_1 = require("./integration");
 const lodash_2 = require("lodash");
+const perform_1 = require("./perform");
 const convertIntegration = (definition) => {
     var _a, _b, _c;
     // Generate a unique reference key that will be used to reference the
@@ -546,7 +547,7 @@ const convertOnExecution = (onExecution, componentRegistry) => (context, params)
         }, {});
         return Object.assign(Object.assign({}, accumulator), { [registryComponentKey]: componentActions });
     }, {});
-    return onExecution(Object.assign(Object.assign({}, context), { components: componentMethods }), params);
+    return onExecution(Object.assign(Object.assign({}, context), { components: componentMethods, invokeFlow: (0, perform_1.createInvokeFlow)(context, { isCNI: true }) }), params);
 };
 /** Creates the structure necessary to import a Component as part of a
  *  Code Native integration. */

package/dist/serverTypes/index.d.ts

@@ -1,4 +1,4 @@
-import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest, FlowInvoker, ExecutionFrame } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -47,7 +47,7 @@ export interface ActionLogger {
     warn: ActionLoggerFunction;
     error: ActionLoggerFunction;
 }
-export type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>> = {
+export type ActionContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>, TFlows extends string[] = string[]> = {
     logger: ActionLogger;
     instanceState: Record<string, unknown>;
     crossFlowState: Record<string, unknown>;
@@ -70,6 +70,8 @@ export type ActionContext<TConfigVars extends ConfigVarResultCollection = Config
     integration: IntegrationAttributes;
     flow: FlowAttributes;
     startedAt: string;
+    invokeFlow: FlowInvoker<TFlows>;
+    executionFrame: ExecutionFrame;
 };
 type TriggerOptionChoice = "invalid" | "valid" | "required";
 export interface TriggerPayload {

package/dist/serverTypes/index.js

@@ -1,4 +1,6 @@
 "use strict";
+/* Types used to describe the format the platform expects for
+ * component and integration definitions. */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OAuth2Type = void 0;
 var OAuth2Type;

package/dist/serverTypes/perform.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorHandler, Inputs, PollingTriggerPerformFunction } from "../types";
+import type { ActionContext, ErrorHandler, FlowInvoker, Inputs, PollingTriggerPerformFunction } from "../types";
 import { type PollingTriggerDefinition } from "../types/PollingTriggerDefinition";
 export type PerformFn = (...args: any[]) => Promise<any>;
 export type CleanFn = (...args: any[]) => any;
@@ -8,6 +8,9 @@ interface CreatePerformProps {
     errorHandler?: ErrorHandler;
 }
 export declare const cleanParams: (params: Record<string, unknown>, cleaners: InputCleaners) => Record<string, any>;
+export declare const createInvokeFlow: <const TFlows extends Readonly<string[]>>(context: ActionContext, options?: {
+    isCNI?: boolean;
+}) => FlowInvoker<TFlows>;
 export declare const createPerform: (performFn: PerformFn, { inputCleaners, errorHandler }: CreatePerformProps) => PerformFn;
 export declare const createPollingPerform: (trigger: PollingTriggerDefinition, { inputCleaners, errorHandler }: CreatePerformProps) => PollingTriggerPerformFunction<Inputs, Inputs>;
 export {};

package/dist/serverTypes/perform.js

@@ -19,8 +19,12 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPollingPerform = exports.createPerform = exports.cleanParams = void 0;
+exports.createPollingPerform = exports.createPerform = exports.createInvokeFlow = exports.cleanParams = void 0;
+const axios_1 = __importDefault(require("axios"));
 const lodash_1 = require("lodash");
 const cleanParams = (params, cleaners) => {
     const keys = (0, lodash_1.uniq)([...Object.keys(params), ...Object.keys(cleaners)]);
@@ -31,6 +35,21 @@ const cleanParams = (params, cleaners) => {
     }, {});
 };
 exports.cleanParams = cleanParams;
+function formatExecutionFrameHeaders(frame, source) {
+    let frameToUse = frame;
+    if (source) {
+        frameToUse = Object.assign(Object.assign({}, frame), { customSource: source });
+    }
+    return JSON.stringify(frameToUse);
+}
+const createInvokeFlow = (context, options = {}) => {
+    return (flowName, data, config, source) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const sourceToUse = options.isCNI ? source : undefined;
+        return yield axios_1.default.post(context.webhookUrls[flowName], data, Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, ((_a = config === null || config === void 0 ? void 0 : config.headers) !== null && _a !== void 0 ? _a : {})), { "prismatic-invoked-by": formatExecutionFrameHeaders(context.executionFrame, sourceToUse), "prismatic-invoke-type": "Cross Flow" }) }));
+    });
+};
+exports.createInvokeFlow = createInvokeFlow;
 const createPerform = (performFn, { inputCleaners, errorHandler }) => {
     return (...args) => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -40,10 +59,10 @@ const createPerform = (performFn, { inputCleaners, errorHandler }) => {
             }
             if (args.length === 2) {
                 const [context, params] = args;
-                return yield performFn(context, (0, exports.cleanParams)(params, inputCleaners));
+                return yield performFn(Object.assign(Object.assign({}, context), { invokeFlow: (0, exports.createInvokeFlow)(context) }), (0, exports.cleanParams)(params, inputCleaners));
             }
             const [context, payload, params] = args;
-            return yield performFn(context, payload, (0, exports.cleanParams)(params, inputCleaners));
+            return yield performFn(Object.assign(Object.assign({}, context), { invokeFlow: (0, exports.createInvokeFlow)(context) }), payload, (0, exports.cleanParams)(params, inputCleaners));
         }
         catch (error) {
             throw errorHandler ? errorHandler(error) : error;
@@ -69,6 +88,7 @@ const createPollingPerform = (trigger, { inputCleaners, errorHandler }) => {
         try {
             const { pollAction } = trigger;
             const pollingContext = {
+                invokeFlow: (0, exports.createInvokeFlow)(context),
                 polling: {
                     invokeAction: createInvokePollAction(context, pollAction, {
                         inputCleaners,

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, DataSourceResult, DataSourceContext } from "./serverTypes";
-import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceType, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow, ConfigVarResultCollection } from "./types";
+import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionPerformReturn, DataSourceResult, DataSourceContext } from "./serverTypes";
+import { ActionContext, ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceType, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow, ConfigVarResultCollection } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>, tokenValues?: Record<string, unknown>) => ConnectionValue;
 export declare const defaultConnectionValueEnvironmentVariable = "PRISMATIC_CONNECTION_VALUE";
 export declare const connectionValue: (envVarKey?: string) => ConnectionValue;

package/dist/testing.js

@@ -48,6 +48,11 @@ const loggerMock = () => ({
     error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
+function invokeFlowTest(flowName, data, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve({});
+    });
+}
 const createActionContext = (context) => {
     return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, configVars: {}, components: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
             "Flow 1": "https://example.com",
@@ -73,7 +78,15 @@ const createActionContext = (context) => {
         }, flow: {
             id: "flowId",
             name: "Flow 1",
-        }, startedAt: new Date().toISOString() }, context);
+        }, startedAt: new Date().toISOString(), invokeFlow: invokeFlowTest, executionFrame: {
+            invokedByExecutionJWT: "some-jwt",
+            invokedByExecutionStartedAt: "00-00-0000",
+            componentActionKey: "my-component-action-key",
+            executionId: "abc-123",
+            executionStartedAt: "",
+            stepName: "some-step",
+            loopPath: "",
+        } }, context);
 };
 const createDataSourceContext = (context) => {
     return Object.assign({ logger: (0, exports.loggerMock)(), configVars: {}, customer: {

package/dist/types/ActionPerformFunction.d.ts

@@ -1,8 +1,27 @@
+import { AxiosRequestConfig, AxiosResponse } from "axios";
 import { Inputs, ConfigVarResultCollection, ActionPerformReturn, ActionInputParameters, ActionLogger, InstanceAttributes, CustomerAttributes, UserAttributes, IntegrationAttributes, FlowAttributes, ComponentManifest } from ".";
+interface StandardLineage {
+    componentActionKey: string;
+    executionId: string;
+    executionStartedAt: string;
+    stepName: string;
+    loopPath: string;
+}
+interface CustomLineage {
+    customSource: string;
+}
+export type ExecutionFrame = ({
+    invokedByExecutionJWT: string;
+    invokedByExecutionStartedAt: string;
+} & StandardLineage) | ({
+    invokedByExecutionJWT: string;
+    invokedByExecutionStartedAt: string;
+} & 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>;
 /** 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"]>> = {
+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 */
     logger: ActionLogger;
     /** A a flow-specific key/value store that may be used to store small amounts of data that is persisted between Instance executions */
@@ -43,4 +62,9 @@ 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.. */
+    invokeFlow: FlowInvoker<TFlows>;
+    /** Reference to the current execution and, when applicable, the current step. */
+    executionFrame: ExecutionFrame;
 };
+export {};

package/dist/types/PollingTriggerDefinition.d.ts

@@ -1,4 +1,4 @@
-import type { ActionDisplayDefinition, TriggerEventFunction, Inputs, ConfigVarResultCollection, TriggerPayload, ActionDefinition, ActionContext, ActionInputParameters, ActionPerformReturn, TriggerResult } from ".";
+import type { ActionDisplayDefinition, TriggerEventFunction, Inputs, ConfigVarResultCollection, TriggerPayload, ActionDefinition, ActionInputParameters, ActionPerformReturn, TriggerResult, ActionContext } from ".";
 export interface PollingContext<TInputs extends Inputs = Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection> extends ActionContext<TConfigVars> {
     polling: {
         invokeAction: (params: ActionInputParameters<TInputs>) => Promise<ActionPerformReturn<boolean, any>>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "10.3.0",
-  "description": "Utility library for building Prismatic components and code-native integrations",
+  "version": "10.3.2",
+  "description": "Utility library for building Prismatic connectors and code-native integrations",
   "keywords": ["prismatic"],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",