@prismatic-io/spectral 10.20.0 → 10.21.1-preview.0

package/dist/generators/cniComponentManifest/index.js

@@ -134,15 +134,10 @@ const fetchComponentDataForManifest = (_a) => __awaiter(void 0, [_a], void 0, fu
                 };
             }
             else {
-                actions[node.key] = {
-                    key: node.key,
-                    display: {
+                actions[node.key] = Object.assign(Object.assign({ key: node.key, display: {
                         label: node.label,
                         description: node.description,
-                    },
-                    inputs: transformInputNodes(node.inputs.nodes),
-                    examplePayload: node.examplePayload,
-                };
+                    }, inputs: transformInputNodes(node.inputs.nodes), examplePayload: node.examplePayload }, (node.examplePerformSafety ? { examplePerformSafety: node.examplePerformSafety } : {})), (node.performSafety ? { performSafety: node.performSafety } : {}));
             }
         });
         const connections = component.connections.nodes.map((node) => {
@@ -245,6 +240,8 @@ function getComponentActions(componentId, prismaticUrl, accessToken) {
                 }
               }
               examplePayload
+              examplePerformSafety
+              performSafety
             }
             pageInfo {
               hasNextPage

package/dist/generators/cniComponentManifest/types.d.ts

@@ -1,5 +1,6 @@
 import type { Action, Component, DataSource, Trigger, TriggerPayload } from "../../serverTypes";
 import type { ConfigVarResultCollection, Inputs } from "../../types";
+import type { PerformSafety } from "../../types/ActionDefinition";
 import type { TriggerResult } from "../../types/TriggerResult";
 export interface ComponentNode {
     id: string;
@@ -28,6 +29,8 @@ export interface ActionNode {
         nodes: InputNode[];
     };
     examplePayload: string | null;
+    examplePerformSafety: PerformSafety | null;
+    performSafety: PerformSafety | null;
 }
 export interface ConnectionNode {
     key: string;
@@ -47,7 +50,10 @@ export interface InputNode {
     shown: boolean;
     onPremiseControlled: boolean;
 }
-export type FormattedAction = Pick<Action, "key" | "display" | "inputs" | "examplePayload">;
+export type FormattedAction = Pick<Action, "key" | "display" | "inputs" | "examplePayload" | "examplePerformSafety" | "performSafety"> & {
+    /** Emitted verbatim into the generated manifest; shape mirrors `examplePayload`. */
+    outputSchema?: unknown;
+};
 export type FormattedTrigger<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> = Pick<Trigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>, "key" | "display" | "inputs">;
 export type FormattedDataSource = Pick<DataSource, "key" | "display" | "inputs" | "dataSourceType" | "examplePayload">;
 export type ComponentForManifest<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> = Pick<Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>, "key" | "public" | "display" | "connections"> & {

package/dist/generators/componentManifest/createActions.js

@@ -44,7 +44,9 @@ const createActions = (_a) => __awaiter(void 0, [_a], void 0, function* ({ compo
         });
         const imports = (0, getImports_1.getImports)({ inputs });
         return yield renderAction({
-            action: Object.assign(Object.assign({ typeInterface: (0, createTypeInterface_1.createTypeInterface)((_b = action.key) !== null && _b !== void 0 ? _b : actionKey), import: (0, createImport_1.createImport)((_c = action.key) !== null && _c !== void 0 ? _c : actionKey), key: action.key || actionKey, label: action.display.label, description: action.display.description, inputs }, (action.examplePayload ? { examplePayload: action.examplePayload } : {})), { componentKey: component.key }),
+            action: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ typeInterface: (0, createTypeInterface_1.createTypeInterface)((_b = action.key) !== null && _b !== void 0 ? _b : actionKey), import: (0, createImport_1.createImport)((_c = action.key) !== null && _c !== void 0 ? _c : actionKey), key: action.key || actionKey, label: action.display.label, description: action.display.description, inputs }, (action.examplePayload ? { examplePayload: action.examplePayload } : {})), (action.outputSchema ? { outputSchema: action.outputSchema } : {})), (action.examplePerformSafety
+                ? { examplePerformSafety: action.examplePerformSafety }
+                : {})), (action.performSafety ? { performSafety: action.performSafety } : {})), { componentKey: component.key }),
             imports,
             dryRun,
             verbose,

package/dist/generators/componentManifest/templates/actions/action.ts.ejs

@@ -25,4 +25,13 @@ export const <%= action.import %> = {
   <%_ if (action.examplePayload) { -%>
   examplePayload: <%- typeof action.examplePayload === 'string' ? action.examplePayload : JSON.stringify(action.examplePayload, null, 2) %>,
   <%_ } -%>
+  <%_ if (action.outputSchema) { -%>
+  outputSchema: <%- typeof action.outputSchema === 'string' ? action.outputSchema : JSON.stringify(action.outputSchema, null, 2) %>,
+  <%_ } -%>
+  <%_ if (action.examplePerformSafety) { -%>
+  examplePerformSafety: "<%= action.examplePerformSafety %>",
+  <%_ } -%>
+  <%_ if (action.performSafety) { -%>
+  performSafety: "<%= action.performSafety %>",
+  <%_ } -%>
 } as const;

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  */
 import { convertComponent } from "./serverTypes/convertComponent";
 import { convertIntegration } from "./serverTypes/convertIntegration";
-import type { ActionDefinition, ActionPerformReturn, BatchTrigger, ComponentDefinition, ComponentManifest, ConfigPage, ConfigVarResultCollection, ConnectionConfigVar, CustomerActivatedConnectionConfigVar, DataSourceConfigVar, DataSourceDefinition, DataSourceType, DefaultConnectionDefinition, DynamicObjectInputField, Flow, InputFieldDefinition, Inputs, IntegrationDefinition, OAuth2ConnectionDefinition, OnPremConnectionDefinition, OrganizationActivatedConnectionConfigVar, StandardConfigVar, StructuredObjectInputField, TriggerDefinition, TriggerPayload, TriggerResult } from "./types";
+import type { ActionDefinition, ActionPerformReturn, BatchTrigger, ComponentDefinition, ComponentManifest, ConfigPage, ConfigVarResultCollection, ConnectionConfigVar, CustomerActivatedConnectionConfigVar, DataSourceConfigVar, DataSourceDefinition, DataSourceType, DefaultConnectionDefinition, DynamicObjectInputField, Flow, InputFieldDefinition, Inputs, IntegrationDefinition, OAuth2ConnectionDefinition, OnPremConnectionDefinition, OrganizationActivatedConnectionConfigVar, OutputSchema, StandardConfigVar, StructuredObjectInputField, TriggerDefinition, TriggerPayload, TriggerResult } from "./types";
 import type { PollingTriggerDefinition } from "./types/PollingTriggerDefinition";
 /**
  * This function creates a code-native integration object that can be
@@ -383,6 +383,38 @@ export declare const component: <TPublic extends boolean, TKey extends string>(d
  * });
  */
 export declare const action: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>;
+/**
+ * Declares the output schema for an action and preserves its literal types,
+ * so authors don't need a trailing `as const` (or `satisfies OutputSchema`)
+ * to keep the `type` discriminant from widening to `string`.
+ *
+ * Wrapping the schema in this helper lets it be hoisted into a standalone
+ * variable and still satisfy the {@link OutputSchema} discriminated union:
+ *
+ * @example
+ * import { action, outputSchema } from "@prismatic-io/spectral";
+ *
+ * // Hoisted out of the action — no `as const` needed.
+ * const listItemsOutput = outputSchema({
+ *   type: "actionOutput",
+ *   schema: {
+ *     type: "object",
+ *     properties: { items: { type: "array" } },
+ *   },
+ * });
+ *
+ * export const listItems = action({
+ *   display: { label: "List Items", description: "..." },
+ *   inputs: {},
+ *   perform: async () => ({ data: { items: [] } }),
+ *   outputSchema: listItemsOutput,
+ * });
+ *
+ * @param definition An {@link OutputSchema} object — either an `actionOutput`
+ *   single-payload schema or a `branchingOutput` per-branch map.
+ * @returns The same object, typed with its literal discriminant preserved.
+ */
+export declare const outputSchema: <const TOutputSchema extends OutputSchema>(definition: TOutputSchema) => TOutputSchema;
 /**
  * This function creates a trigger object that can be referenced
  * by a custom component. It helps ensure that the shape of the

package/dist/index.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = exports.testing = exports.componentManifests = exports.oauth2Connection = exports.onPremConnection = exports.connection = exports.dynamicObjectInput = exports.structuredObjectInput = exports.input = exports.dataSource = exports.pollingTrigger = exports.trigger = exports.action = exports.component = exports.componentManifest = exports.organizationActivatedConnection = exports.customerActivatedConnection = exports.connectionConfigVar = exports.dataSourceConfigVar = exports.configVar = exports.configPage = exports.batchFlowTrigger = exports.flow = exports.integration = void 0;
+exports.util = exports.testing = exports.componentManifests = exports.oauth2Connection = exports.onPremConnection = exports.connection = exports.dynamicObjectInput = exports.structuredObjectInput = exports.input = exports.dataSource = exports.pollingTrigger = exports.trigger = exports.outputSchema = exports.action = exports.component = exports.componentManifest = exports.organizationActivatedConnection = exports.customerActivatedConnection = exports.connectionConfigVar = exports.dataSourceConfigVar = exports.configVar = exports.configPage = exports.batchFlowTrigger = exports.flow = exports.integration = void 0;
 const serverTypes_1 = require("./serverTypes");
 const convertComponent_1 = require("./serverTypes/convertComponent");
 const convertIntegration_1 = require("./serverTypes/convertIntegration");
@@ -426,6 +426,39 @@ exports.component = component;
  */
 const action = (definition) => definition;
 exports.action = action;
+/**
+ * Declares the output schema for an action and preserves its literal types,
+ * so authors don't need a trailing `as const` (or `satisfies OutputSchema`)
+ * to keep the `type` discriminant from widening to `string`.
+ *
+ * Wrapping the schema in this helper lets it be hoisted into a standalone
+ * variable and still satisfy the {@link OutputSchema} discriminated union:
+ *
+ * @example
+ * import { action, outputSchema } from "@prismatic-io/spectral";
+ *
+ * // Hoisted out of the action — no `as const` needed.
+ * const listItemsOutput = outputSchema({
+ *   type: "actionOutput",
+ *   schema: {
+ *     type: "object",
+ *     properties: { items: { type: "array" } },
+ *   },
+ * });
+ *
+ * export const listItems = action({
+ *   display: { label: "List Items", description: "..." },
+ *   inputs: {},
+ *   perform: async () => ({ data: { items: [] } }),
+ *   outputSchema: listItemsOutput,
+ * });
+ *
+ * @param definition An {@link OutputSchema} object — either an `actionOutput`
+ *   single-payload schema or a `branchingOutput` per-branch map.
+ * @returns The same object, typed with its literal discriminant preserved.
+ */
+const outputSchema = (definition) => definition;
+exports.outputSchema = outputSchema;
 /**
  * This function creates a trigger object that can be referenced
  * by a custom component. It helps ensure that the shape of the

package/dist/serverTypes/convertComponent.d.ts

@@ -1,6 +1,6 @@
-import { type ComponentDefinition, type ComponentHooks, type ConfigVarResultCollection, type ConnectionDefinition, type ConnectionInput, type ConnectionTemplateInputField, type InputFieldDefinition, type Inputs, type OnPremConnectionInput, type TriggerDefinition, type TriggerPayload, type TriggerResult } from "../types";
+import { type ActionDefinition, type ComponentDefinition, type ComponentHooks, type ConfigVarResultCollection, type ConnectionDefinition, type ConnectionInput, type ConnectionTemplateInputField, type InputFieldDefinition, type Inputs, type OnPremConnectionInput, type TriggerDefinition, type TriggerPayload, type TriggerResult } from "../types";
 import { type PollingTriggerDefinition } from "../types/PollingTriggerDefinition";
-import type { Component as ServerComponent, Connection as ServerConnection, Input as ServerInput, Trigger as ServerTrigger } from ".";
+import type { Action as ServerAction, Component as ServerComponent, Connection as ServerConnection, Input as ServerInput, Trigger as ServerTrigger } from ".";
 import { type CleanFn } from "./perform";
 /** Auto-generated cleaner for structuredObject/dynamicObject containers.
  * Recursively delegates to each child's clean function. Developers do not
@@ -29,6 +29,7 @@ export declare const _isValidTemplateValue: (template: string, inputs: {
 export declare const convertTemplateInput: (key: string, { templateValue, label, ...rest }: ConnectionTemplateInputField, inputs: {
     [key: string]: ConnectionInput | ConnectionTemplateInputField;
 }) => ServerInput;
+export declare const convertAction: (actionKey: string, { inputs, perform, outputSchema, examplePerform, ...action }: ActionDefinition<Inputs, any, boolean, any>, hooks?: ComponentHooks) => ServerAction;
 export declare const convertTrigger: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>(triggerKey: string, trigger: TriggerDefinition<any> | PollingTriggerDefinition<any, ConfigVarResultCollection, TriggerPayload, boolean, any, any>, hooks?: ComponentHooks) => ServerTrigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
 export declare const convertConnection: ({ inputs, ...connection }: ConnectionDefinition) => ServerConnection;
 export declare const convertComponent: <TPublic extends boolean, TKey extends string, TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ connections, actions, triggers, dataSources, hooks, ...definition }: ComponentDefinition<TPublic, TKey>) => ServerComponent<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;

package/dist/serverTypes/convertComponent.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertComponent = exports.convertConnection = exports.convertTrigger = exports.convertTemplateInput = exports._isValidTemplateValue = exports.convertInput = exports.validateConcurrentBatchLimit = exports.validateBatchSize = exports.cleanerFor = void 0;
+exports.convertComponent = exports.convertConnection = exports.convertTrigger = exports.convertAction = exports.convertTemplateInput = exports._isValidTemplateValue = exports.convertInput = exports.validateConcurrentBatchLimit = exports.validateBatchSize = exports.cleanerFor = void 0;
 const omit_1 = __importDefault(require("lodash/omit"));
 const types_1 = require("../types");
 const PollingTriggerDefinition_1 = require("../types/PollingTriggerDefinition");
@@ -213,15 +213,35 @@ const convertTemplateInput = (key, _a, inputs) => {
     return Object.assign(Object.assign({}, (0, omit_1.default)(rest, ["permissionAndVisibilityType", "visibleToOrgDeployer", "writeOnly"])), { key, type: "template", default: templateValue !== null && templateValue !== void 0 ? templateValue : "", label: typeof label === "string" ? label : label.value, shown: false });
 };
 exports.convertTemplateInput = convertTemplateInput;
+const convertOutputSchema = (outputSchema) => {
+    if (outputSchema.type === "actionOutput") {
+        return { type: "actionOutput", schema: JSON.stringify(outputSchema.schema) };
+    }
+    return {
+        type: "branchingOutput",
+        branchSchemas: Object.entries(outputSchema.branchSchemas).map(([name, schema]) => ({
+            name,
+            schema: JSON.stringify(schema),
+        })),
+    };
+};
 const convertAction = (actionKey, _a, hooks) => {
-    var { inputs = {}, perform } = _a, action = __rest(_a, ["inputs", "perform"]);
+    var { inputs = {}, perform, outputSchema, examplePerform } = _a, action = __rest(_a, ["inputs", "perform", "outputSchema", "examplePerform"]);
     const convertedInputs = Object.entries(inputs).map(([key, value]) => (0, exports.convertInput)(key, value));
     const inputCleaners = Object.entries(inputs).reduce((result, [key, value]) => (Object.assign(Object.assign({}, result), { [key]: (0, exports.cleanerFor)(value) })), {});
-    return Object.assign(Object.assign({}, action), { key: actionKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, action), { key: actionKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
             inputCleaners,
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
-        }) });
+        }) }), (outputSchema ? { outputSchema: convertOutputSchema(outputSchema) } : {})), (examplePerform
+        ? {
+            examplePerform: (0, perform_1.createPerform)(examplePerform, {
+                inputCleaners,
+                errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
+            }),
+        }
+        : {}));
 };
+exports.convertAction = convertAction;
 const convertTrigger = (triggerKey, 
 // `any` is load-bearing: the user-facing TriggerDefinition / PollingTriggerDefinition
 // type their event-function fields (onInstanceDeploy, webhookLifecycleHandlers, etc.) over
@@ -354,7 +374,7 @@ const convertConnection = (_a) => {
 exports.convertConnection = convertConnection;
 const convertComponent = (_a) => {
     var { connections = [], actions = {}, triggers = {}, dataSources = {}, hooks } = _a, definition = __rest(_a, ["connections", "actions", "triggers", "dataSources", "hooks"]);
-    const convertedActions = Object.entries(actions).reduce((result, [actionKey, action]) => (Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, action, hooks) })), {});
+    const convertedActions = Object.entries(actions).reduce((result, [actionKey, action]) => (Object.assign(Object.assign({}, result), { [actionKey]: (0, exports.convertAction)(actionKey, action, hooks) })), {});
     const convertedTriggers = Object.entries(triggers).reduce((result, [triggerKey, trigger]) => (Object.assign(Object.assign({}, result), { [triggerKey]: (0, exports.convertTrigger)(triggerKey, trigger, hooks) })), {});
     const convertedDataSources = Object.entries(dataSources).reduce((result, [dataSourceKey, dataSource]) => (Object.assign(Object.assign({}, result), { [dataSourceKey]: convertDataSource(dataSourceKey, dataSource, hooks) })), {});
     return Object.assign(Object.assign({}, definition), { connections: connections.map(exports.convertConnection), actions: convertedActions, triggers: convertedTriggers, dataSources: convertedDataSources });

package/dist/serverTypes/index.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentManifest, ConfigVarResultCollection, CustomerAttributes, DataSourceResultType, DataSourceType, DebugContext, ExecutionFrame, FlowAttributes, FlowInvoker, FlowSchemas, Inputs, InstanceAttributes, IntegrationAttributes, PollingTriggerPerformFunction, TriggerEventFunctionReturn, TriggerPerformFunction, TriggerResult as TriggerPerformResult, UserAttributes } from "../types";
+import type { ComponentManifest, ConfigVarResultCollection, CustomerAttributes, DataSourceResultType, DataSourceType, DebugContext, ExecutionFrame, FlowAttributes, FlowInvoker, FlowSchemas, Inputs, InstanceAttributes, IntegrationAttributes, PerformSafety, PollingTriggerPerformFunction, TriggerEventFunctionReturn, TriggerPerformFunction, TriggerResult as TriggerPerformResult, UserAttributes } from "../types";
 import type { CNIPollingPerformFunction, ComponentRefTriggerPerformFunction } from "./triggerTypes";
 interface DisplayDefinition {
     label: string;
@@ -40,7 +40,28 @@ export interface Action {
     dynamicBranchInput?: string;
     perform: ActionPerformFunction;
     examplePayload?: unknown;
+    /**
+     * The on-the-wire form of an action's `outputSchema`, as accepted by the
+     * `PublishComponent` mutation. JSON Schemas are serialized to strings and the
+     * branching variant's per-branch map is flattened to a `{ name, schema }`
+     * list (GraphQL input has no map type). Produced by `convertOutputSchema`
+     * from the author-facing `OutputSchema`.
+     */
+    outputSchema?: ServerOutputSchema;
+    examplePerform?: ActionPerformFunction;
+    examplePerformSafety?: PerformSafety;
+    performSafety?: PerformSafety;
 }
+export type ServerOutputSchema = {
+    type: "actionOutput";
+    schema: string;
+} | {
+    type: "branchingOutput";
+    branchSchemas: Array<{
+        name: string;
+        schema: string;
+    }>;
+};
 export type ActionLoggerFunction = (...args: unknown[]) => void;
 export interface ActionLogger {
     metric: ActionLoggerFunction;

package/dist/serverTypes/inlineActionCalling.publishWire.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/serverTypes/inlineActionCalling.publishWire.spec.js

@@ -0,0 +1,167 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Verifies what spectral serializes for the inline-action example-perform fields
+ * on publish — the converted server component `prism component publish` sends.
+ *
+ * Scope is conversion output only: which fields land on the wire, with what values.
+ * It does not verify runtime dispatch (SAFE vs. UNSAFE vs. NOT_ALLOWED choosing
+ * which perform runs) — the safety flags are inert metadata spectral passes through
+ * verbatim, and the runner decides at execution time.
+ */
+const ejs_1 = require("ejs");
+const path_1 = __importDefault(require("path"));
+const vitest_1 = require("vitest");
+const helpers_1 = require("../generators/componentManifest/helpers");
+const index_1 = require("../index");
+const display = (label) => ({ label, description: label });
+// Three input shapes exercised on every permutation.
+const connectionInput = (0, index_1.input)({ label: "Connection", type: "connection", required: true });
+const structuredInput = (0, index_1.structuredObjectInput)({
+    label: "Name",
+    inputs: {
+        first: (0, index_1.input)({ type: "string", label: "First", required: true }),
+        last: (0, index_1.input)({ type: "string", label: "Last", required: true }),
+    },
+});
+const collectionInput = (0, index_1.input)({ label: "Tags", type: "string", collection: "valuelist" });
+const sharedInputs = {
+    connection: connectionInput,
+    name: structuredInput,
+    tags: collectionInput,
+};
+const noop = () => __awaiter(void 0, void 0, void 0, function* () { return ({ data: null }); });
+const echo = (_ctx, params) => __awaiter(void 0, void 0, void 0, function* () { return ({ data: params }); });
+// Action permutations.
+const testComponent = (0, index_1.component)({
+    key: "inline-action-testbed",
+    public: false,
+    display: Object.assign(Object.assign({}, display("Inline Action Testbed")), { iconPath: "icon.png" }),
+    actions: {
+        // A — no inline-calling fields.
+        plainAction: (0, index_1.action)({
+            display: display("Plain Action"),
+            inputs: sharedInputs,
+            perform: noop,
+        }),
+        // B — example perform + its safety flag.
+        examplePerformAction: (0, index_1.action)({
+            display: display("Example Perform Action"),
+            inputs: sharedInputs,
+            perform: noop,
+            examplePerform: echo,
+            examplePerformSafety: index_1.PerformSafety.SAFE,
+        }),
+        // C — real perform marked runnable.
+        runnablePerformAction: (0, index_1.action)({
+            display: display("Runnable Perform Action"),
+            inputs: sharedInputs,
+            perform: noop,
+            performSafety: index_1.PerformSafety.UNSAFE,
+        }),
+        // D — real perform marked not runnable.
+        notAllowedPerformAction: (0, index_1.action)({
+            display: display("Not Allowed Perform Action"),
+            inputs: sharedInputs,
+            perform: noop,
+            performSafety: index_1.PerformSafety.NOT_ALLOWED,
+        }),
+    },
+});
+// Converted actions are keyed by action key.
+const actionsByKey = testComponent.actions;
+(0, vitest_1.describe)("inline action calling: publish-wire conversion output", () => {
+    (0, vitest_1.it)("A — plain action: no inline-calling fields leak onto the wire", () => {
+        const a = actionsByKey.plainAction;
+        (0, vitest_1.expect)("examplePerform" in a).toBe(false);
+        (0, vitest_1.expect)(a.examplePerformSafety).toBeUndefined();
+        (0, vitest_1.expect)(a.performSafety).toBeUndefined();
+    });
+    (0, vitest_1.it)("B — example perform is wrapped (invokable) and its safety flag is carried", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const a = actionsByKey.examplePerformAction;
+        (0, vitest_1.expect)(typeof a.examplePerform).toBe("function");
+        (0, vitest_1.expect)(a.examplePerformSafety).toBe("SAFE");
+        // Only the field the author set is carried; no performSafety leaks in.
+        (0, vitest_1.expect)(a.performSafety).toBeUndefined();
+        // Wrapped fn is invokable and passes params through.
+        const result = yield ((_a = a.examplePerform) === null || _a === void 0 ? void 0 : _a.call(a, {}, { tags: ["x"] }));
+        (0, vitest_1.expect)(result.data.tags).toStrictEqual(["x"]);
+    }));
+    (0, vitest_1.it)("C — real-perform UNSAFE flag carried; no separate example perform", () => {
+        const a = actionsByKey.runnablePerformAction;
+        (0, vitest_1.expect)(a.performSafety).toBe("UNSAFE");
+        (0, vitest_1.expect)("examplePerform" in a).toBe(false);
+        (0, vitest_1.expect)(a.examplePerformSafety).toBeUndefined();
+    });
+    (0, vitest_1.it)("D — real-perform NOT_ALLOWED flag carried verbatim; no example perform", () => {
+        const a = actionsByKey.notAllowedPerformAction;
+        (0, vitest_1.expect)(a.performSafety).toBe("NOT_ALLOWED");
+        (0, vitest_1.expect)("examplePerform" in a).toBe(false);
+        (0, vitest_1.expect)(a.examplePerformSafety).toBeUndefined();
+    });
+    (0, vitest_1.it)("the three input shapes survive conversion on every permutation", () => {
+        for (const key of [
+            "plainAction",
+            "examplePerformAction",
+            "runnablePerformAction",
+            "notAllowedPerformAction",
+        ]) {
+            const inputs = actionsByKey[key].inputs;
+            const byKey = Object.fromEntries(inputs.map((i) => [i.key, i]));
+            (0, vitest_1.expect)(byKey.connection.type).toBe("connection");
+            (0, vitest_1.expect)(byKey.name.type).toBe("structuredObject");
+            (0, vitest_1.expect)(byKey.name.inputs).toHaveLength(2); // nested children survived
+            (0, vitest_1.expect)(byKey.tags.collection).toBe("valuelist");
+        }
+    });
+});
+(0, vitest_1.describe)("inline action calling: component-manifest emit", () => {
+    const templatePath = path_1.default.join(__dirname, "../generators/componentManifest/templates/actions/action.ts.ejs");
+    const baseAction = {
+        typeInterface: "DoThing",
+        import: "doThing",
+        key: "doThing",
+        label: "Do Thing",
+        description: "Does a thing.",
+        inputs: [],
+        componentKey: "testbed",
+    };
+    const render = (extra) => (0, ejs_1.renderFile)(templatePath, { action: Object.assign(Object.assign({}, baseAction), extra), helpers: helpers_1.helpers, imports: {} });
+    (0, vitest_1.it)("emits both *Safety scalars when present", () => __awaiter(void 0, void 0, void 0, function* () {
+        const out = yield render({
+            examplePerformSafety: "SAFE",
+            performSafety: "UNSAFE",
+        });
+        (0, vitest_1.expect)(out).toContain('examplePerformSafety: "SAFE"');
+        (0, vitest_1.expect)(out).toContain('performSafety: "UNSAFE"');
+    }));
+    (0, vitest_1.it)("emits a NOT_ALLOWED performSafety scalar verbatim", () => __awaiter(void 0, void 0, void 0, function* () {
+        const out = yield render({ performSafety: "NOT_ALLOWED" });
+        (0, vitest_1.expect)(out).toContain('performSafety: "NOT_ALLOWED"');
+    }));
+    (0, vitest_1.it)("omits the *Safety scalars when absent (permutation A)", () => __awaiter(void 0, void 0, void 0, function* () {
+        const out = yield render({});
+        (0, vitest_1.expect)(out).not.toContain("examplePerformSafety");
+        (0, vitest_1.expect)(out).not.toContain("performSafety");
+    }));
+    (0, vitest_1.it)("never emits an examplePerform stub (invoked via the server action, not the manifest)", () => __awaiter(void 0, void 0, void 0, function* () {
+        const out = yield render({
+            examplePerformSafety: "SAFE",
+            performSafety: "UNSAFE",
+        });
+        (0, vitest_1.expect)(out).not.toContain("examplePerform:");
+    }));
+});

package/dist/types/ActionDefinition.d.ts

@@ -3,6 +3,17 @@ import type { ActionPerformReturn } from "./ActionPerformReturn";
 import type { ComponentManifestAction } from "./ComponentManifest";
 import type { ActionDisplayDefinition } from "./DisplayDefinition";
 import type { ConfigVarResultCollection, Inputs } from "./Inputs";
+import type { OutputSchema } from "./OutputSchema";
+/**
+ * Whether a perform is safe to invoke inline (to populate reference data in the Prismatic UI):
+ * `SAFE` to run as-is, `UNSAFE` if running has side effects, `NOT_ALLOWED` to opt out.
+ */
+export declare const PerformSafety: {
+    readonly SAFE: "SAFE";
+    readonly UNSAFE: "UNSAFE";
+    readonly NOT_ALLOWED: "NOT_ALLOWED";
+};
+export type PerformSafety = (typeof PerformSafety)[keyof typeof PerformSafety];
 /**
  * ActionDefinition is the type of the object that is passed in to `action` function to
  * define a component action. See
@@ -13,6 +24,9 @@ export interface ActionDefinition<TInputs extends Inputs = Inputs, TConfigVars e
     display: ActionDisplayDefinition;
     /** The function to perform when this action is invoked. */
     perform: ActionPerformFunction<TInputs, TConfigVars, Record<string, Record<string, ComponentManifestAction>>, TAllowsBranching, TReturn>;
+    examplePerform?: ActionPerformFunction<TInputs, TConfigVars, Record<string, Record<string, ComponentManifestAction>>, TAllowsBranching, TReturn>;
+    examplePerformSafety?: PerformSafety;
+    performSafety?: PerformSafety;
     /**
      * The inputs to present a low-code integration builder. Values of these inputs
      * are passed to the `perform` function when the action is invoked.
@@ -37,4 +51,18 @@ export interface ActionDefinition<TInputs extends Inputs = Inputs, TConfigVars e
     dynamicBranchInput?: string;
     /** An example of the payload output by this action. */
     examplePayload?: Awaited<ReturnType<this["perform"]>>;
+    /**
+     * Declares the shape of this action's output `data` as a JSON Schema, used by
+     * the Prismatic UI to let integration authors reference this step's output
+     * before a real execution has produced data. A discriminated union:
+     * `{ type: "actionOutput", schema }` for a single payload shape, or
+     * `{ type: "branchingOutput", branchSchemas }` for a per-branch map of shapes.
+     * Descriptive only — it is not enforced at runtime.
+     *
+     * @remarks
+     * Describes the `data` payload only, not the full return envelope
+     * (`statusCode`, `contentType`, state fields). `branchingOutput` requires
+     * `staticBranchNames`; it is not supported with `dynamicBranchInput`.
+     */
+    outputSchema?: OutputSchema;
 }

package/dist/types/ActionDefinition.js

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformSafety = void 0;
+/**
+ * Whether a perform is safe to invoke inline (to populate reference data in the Prismatic UI):
+ * `SAFE` to run as-is, `UNSAFE` if running has side effects, `NOT_ALLOWED` to opt out.
+ */
+exports.PerformSafety = {
+    SAFE: "SAFE",
+    UNSAFE: "UNSAFE",
+    NOT_ALLOWED: "NOT_ALLOWED",
+};

package/dist/types/ComponentManifest.d.ts

@@ -1,6 +1,8 @@
+import type { PerformSafety } from "./ActionDefinition";
 import type { CollectionType } from "./ConfigVars";
 import type { DataSourceType } from "./DataSourceResult";
 import type { InputFieldType } from "./Inputs";
+import type { OutputSchema } from "./OutputSchema";
 export interface ComponentManifest {
     key: string;
     public: boolean;
@@ -19,8 +21,13 @@ interface BaseInput {
 export interface ComponentManifestAction {
     key?: string;
     perform: (values: any) => Promise<unknown>;
+    examplePerform?: (values: any) => Promise<unknown>;
+    examplePerformSafety?: PerformSafety;
+    performSafety?: PerformSafety;
     inputs: Record<string, BaseInput>;
     examplePayload?: unknown;
+    /** Declares the shape of this action's output `data` as a JSON Schema (discriminated union: actionOutput | branchingOutput). */
+    outputSchema?: OutputSchema;
 }
 export interface ComponentManifestTrigger {
     key?: string;

package/dist/types/OutputSchema.d.ts

@@ -0,0 +1,35 @@
+import type { JsonSchema } from "./jsonforms/JsonSchema";
+/**
+ * Describes the shape of a non-branching action's output `data` payload as a
+ * JSON Schema. Used by the Prismatic UI to let integration authors reference a
+ * step's output before a real execution has produced data. Descriptive only —
+ * it is not enforced at runtime.
+ */
+export interface ActionOutputSchema {
+    type: "actionOutput";
+    schema: JsonSchema;
+}
+/**
+ * Describes the output `data` payload of a branching action, one JSON Schema
+ * per branch keyed by branch name. A branching action returns `{ branch, data }`,
+ * and the `data` shape may differ per branch, so each branch carries its own
+ * schema. Descriptive only — not enforced at runtime.
+ *
+ * @remarks
+ * Valid only for actions with `staticBranchNames` — a closed, build-time list.
+ * NOT supported with `dynamicBranchInput`, where branch names are computed at
+ * runtime and cannot be enumerated; publishing such a component is rejected
+ * server-side. (Unrelated to `dynamicObject` *inputs*, whose `configurations`
+ * are fully declared at build time — that's an input feature and does not
+ * affect `outputSchema`.)
+ */
+export interface BranchingOutputSchema {
+    type: "branchingOutput";
+    branchSchemas: Record<string, JsonSchema>;
+}
+/**
+ * The output-schema contract declared on an action via `outputSchema`. A
+ * discriminated union on `type`: `actionOutput` for a single payload shape,
+ * `branchingOutput` for a per-branch map of payload shapes.
+ */
+export type OutputSchema = ActionOutputSchema | BranchingOutputSchema;

package/dist/types/OutputSchema.js

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

package/dist/types/index.d.ts

@@ -27,9 +27,9 @@ export * from "./Inputs";
 export * from "./InstanceAttributes";
 export * from "./IntegrationAttributes";
 export * from "./IntegrationDefinition";
+export * from "./OutputSchema";
 export * from "./PollingTriggerDefinition";
 export * from "./ScopedConfigVars";
-export * from "./ScopedConfigVars";
 export * from "./TriggerDefinition";
 export * from "./TriggerEventFunction";
 export * from "./TriggerPayload";

package/dist/types/index.js

@@ -43,9 +43,9 @@ __exportStar(require("./Inputs"), exports);
 __exportStar(require("./InstanceAttributes"), exports);
 __exportStar(require("./IntegrationAttributes"), exports);
 __exportStar(require("./IntegrationDefinition"), exports);
+__exportStar(require("./OutputSchema"), exports);
 __exportStar(require("./PollingTriggerDefinition"), exports);
 __exportStar(require("./ScopedConfigVars"), exports);
-__exportStar(require("./ScopedConfigVars"), exports);
 __exportStar(require("./TriggerDefinition"), exports);
 __exportStar(require("./TriggerEventFunction"), exports);
 __exportStar(require("./TriggerPayload"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "10.20.0",
+  "version": "10.21.1-preview.0",
   "description": "Utility library for building Prismatic connectors and code-native integrations",
   "keywords": [
     "prismatic"