Added convert layer for outputSchema

Author: CaptainChemist

packages/spectral/src/generators/cniComponentManifest/types.ts

@@ -52,10 +52,10 @@ export interface InputNode {
   onPremiseControlled: boolean;
 }
 
-export type FormattedAction = Pick<
-  Action,
-  "key" | "display" | "inputs" | "examplePayload" | "outputSchema"
->;
+export type FormattedAction = Pick<Action, "key" | "display" | "inputs" | "examplePayload"> & {
+  /** Emitted verbatim into the generated manifest; shape mirrors `examplePayload`. */
+  outputSchema?: unknown;
+};
 export type FormattedTrigger<
   TInputs extends Inputs,
   TActionInputs extends Inputs,

packages/spectral/src/generators/componentManifest/createActions.ts

@@ -1,6 +1,5 @@
 import path from "path";
 import type { ConfigVarResultCollection, Inputs, TriggerPayload, TriggerResult } from "../../types";
-import type { OutputSchema } from "../../types/OutputSchema";
 import type { ComponentForManifest } from "../cniComponentManifest/types";
 import { createImport } from "../utils/createImport";
 import { createTemplate } from "../utils/createTemplate";
@@ -150,7 +149,7 @@ interface RenderActionProps {
     description: string;
     inputs: Input[];
     examplePayload?: unknown;
-    outputSchema?: OutputSchema;
+    outputSchema?: unknown;
     componentKey: string;
   };
   dryRun: boolean;

packages/spectral/src/serverTypes/convertComponent.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it, vi } from "vitest";
-import { connection, dynamicObjectInput, input, structuredObjectInput, trigger } from "..";
+import {
+  action,
+  component,
+  connection,
+  dynamicObjectInput,
+  input,
+  structuredObjectInput,
+  trigger,
+} from "..";
 import {
   cleanerFor,
   convertConnection,
@@ -554,3 +562,52 @@ describe("cleanerFor", () => {
     });
   });
 });
+
+describe("convertComponent outputSchema", () => {
+  // `component()` is `convertComponent()`, i.e. the real publish path.
+  const convertedAction = (outputSchema?: unknown) =>
+    (
+      component({
+        key: "acme",
+        public: false,
+        display: { label: "Acme", description: "Acme", iconPath: "icon.png" },
+        actions: {
+          doThing: action({
+            display: { label: "Do Thing", description: "Does the thing" },
+            inputs: {},
+            ...(outputSchema ? { outputSchema } : {}),
+            perform: async () => ({ data: {} }),
+          } as any),
+        },
+      } as any).actions as any
+    ).doThing;
+
+  it("serializes an actionOutput schema to a JSON string", () => {
+    const schema = { type: "object", properties: { id: { type: "string" } } };
+    const { outputSchema } = convertedAction({ type: "actionOutput", schema });
+
+    expect(outputSchema).toEqual({ type: "actionOutput", schema: JSON.stringify(schema) });
+    expect(typeof outputSchema.schema).toBe("string");
+  });
+
+  it("flattens branchingOutput branchSchemas to a list of stringified name/schema pairs", () => {
+    const found = { type: "object", properties: { id: { type: "string" } } };
+    const notFound = { type: "object" };
+    const { outputSchema } = convertedAction({
+      type: "branchingOutput",
+      branchSchemas: { found, notFound },
+    });
+
+    expect(outputSchema).toEqual({
+      type: "branchingOutput",
+      branchSchemas: [
+        { name: "found", schema: JSON.stringify(found) },
+        { name: "notFound", schema: JSON.stringify(notFound) },
+      ],
+    });
+  });
+
+  it("omits outputSchema when the action declares none", () => {
+    expect(convertedAction()).not.toHaveProperty("outputSchema");
+  });
+});

packages/spectral/src/serverTypes/convertComponent.ts

@@ -12,6 +12,7 @@ import {
   type InputFieldDefinition,
   type Inputs,
   type OnPremConnectionInput,
+  type OutputSchema,
   type TriggerDefinition,
   type TriggerOptionChoice,
   type TriggerPayload,
@@ -28,6 +29,7 @@ import type {
   Connection as ServerConnection,
   DataSource as ServerDataSource,
   Input as ServerInput,
+  ServerOutputSchema,
   Trigger as ServerTrigger,
 } from ".";
 import {
@@ -279,9 +281,22 @@ export const convertTemplateInput = (
   };
 };
 
+const convertOutputSchema = (outputSchema: OutputSchema): ServerOutputSchema => {
+  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: string,
-  { inputs = {}, perform, ...action }: ActionDefinition<Inputs, any, boolean, any>,
+  { inputs = {}, perform, outputSchema, ...action }: ActionDefinition<Inputs, any, boolean, any>,
   hooks?: ComponentHooks,
 ): ServerAction => {
   const convertedInputs = Object.entries(inputs).map(([key, value]) => convertInput(key, value));
@@ -298,6 +313,7 @@ const convertAction = (
       inputCleaners,
       errorHandler: hooks?.error,
     }),
+    ...(outputSchema ? { outputSchema: convertOutputSchema(outputSchema) } : {}),
   };
 };
 

packages/spectral/src/serverTypes/index.ts

@@ -21,7 +21,6 @@ import type {
   TriggerResult as TriggerPerformResult,
   UserAttributes,
 } from "../types";
-import type { OutputSchema } from "../types/OutputSchema";
 import type { CNIPollingPerformFunction, ComponentRefTriggerPerformFunction } from "./triggerTypes";
 
 interface DisplayDefinition {
@@ -82,10 +81,20 @@ export interface Action {
   dynamicBranchInput?: string;
   perform: ActionPerformFunction;
   examplePayload?: unknown;
-  /** Declares the shape of this action's output `data` as a JSON Schema (discriminated union: actionOutput | branchingOutput). */
-  outputSchema?: OutputSchema;
+  /**
+   * 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;
 }
 
+export type ServerOutputSchema =
+  | { type: "actionOutput"; schema: string }
+  | { type: "branchingOutput"; branchSchemas: Array<{ name: string; schema: string }> };
+
 export type ActionLoggerFunction = (...args: unknown[]) => void;
 
 export interface ActionLogger {

packages/spectral/src/types/index.ts

@@ -31,7 +31,6 @@ export * from "./IntegrationDefinition";
 export * from "./OutputSchema";
 export * from "./PollingTriggerDefinition";
 export * from "./ScopedConfigVars";
-export * from "./ScopedConfigVars";
 export * from "./TriggerDefinition";
 export * from "./TriggerEventFunction";
 export * from "./TriggerPayload";