feat: manage schema input

Signed-off-by: Simon Emms <simon@simonemms.com>

Author: mrsimonemms

src/lib/export/yaml.ts

@@ -133,7 +133,11 @@ function exportWorkflows(file: WorkflowFile, ctx: ExportContext): unknown[] {
     const wf = file.workflows[id];
     if (!wf) return {};
     const tasks = exportFlowGraphTasks(wf.root, ctx);
-    return { [wf.name]: { do: tasks } };
+    const wfDef: Record<string, unknown> = { do: tasks };
+    if (wf.inputSchema !== undefined) {
+      wfDef.schema = { format: 'json', document: wf.inputSchema };
+    }
+    return { [wf.name]: wfDef };
   });
 }
 

src/lib/i18n/messages/en.json

@@ -403,6 +403,11 @@
       "bodyCount": "body ({{count}} tasks)"
     }
   },
+  "inputSelector": {
+    "placeholder": "Select a field…",
+    "switchToExpression": "Use expression",
+    "switchToSelect": "Select field"
+  },
   "validation": {
     "loop": {
       "collectionRequired": "Collection is required",

src/lib/tasks/model.ts

@@ -47,10 +47,27 @@ export type WorkflowFile = {
   order: string[]; // stable ordering of named workflows
 };
 
+// ---------------------------------------------------------------------------
+// JSON Schema (subset) — used for workflow input schema definitions.
+// Only `type: object` with `properties` is supported; other JSON Schema
+// keywords are preserved for round-trip fidelity but not interpreted.
+// ---------------------------------------------------------------------------
+
+export type JsonSchema = {
+  type?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  title?: string;
+  description?: string;
+};
+
 export type NamedWorkflow = {
   id: string;
   name: string;
   root: FlowGraph;
+  // Optional input schema — maps to `schema: { format: json, document: ... }`
+  // in the Zigflow DSL YAML. Used by the Studio to offer field-picker UX.
+  inputSchema?: JsonSchema;
 };
 
 // ---------------------------------------------------------------------------

src/lib/tasks/parse.ts

@@ -48,6 +48,7 @@ import type {
   FlowGraph,
   ForkBranch,
   ForkNode,
+  JsonSchema,
   LifetimePolicy,
   ListenConfig,
   ListenEvent,
@@ -138,7 +139,20 @@ export function parseWorkflowFile(
   }
 
   // Old format: flat steps with hoisted sub-graph entries.
-  return parseOldFormat(doEntries, document, ctx);
+  const oldResult = parseOldFormat(doEntries, document, ctx);
+  // Parse top-level schema for the single workflow in old format.
+  const topLevelSchema = parseWorkflowSchema(raw);
+  if (topLevelSchema !== undefined) {
+    const wfId = oldResult.workflowFile.order[0]!;
+    const wf = oldResult.workflowFile.workflows[wfId];
+    if (wf) {
+      oldResult.workflowFile.workflows[wfId] = {
+        ...wf,
+        inputSchema: topLevelSchema,
+      };
+    }
+  }
+  return oldResult;
 }
 
 // ---------------------------------------------------------------------------
@@ -167,6 +181,9 @@ function parseNewFormat(
     const root = parseGraph(steps, new Map(), new Set(), ctx);
     const id = crypto.randomUUID();
     const workflow: NamedWorkflow = { id, name, root };
+    // Parse optional input schema: schema: { format: json, document: { ... } }
+    const inputSchema = parseWorkflowSchema(def);
+    if (inputSchema !== undefined) workflow.inputSchema = inputSchema;
     workflows[id] = workflow;
     order.push(id);
   }
@@ -798,6 +815,22 @@ function parseTryNode(
   return node;
 }
 
+// ---------------------------------------------------------------------------
+// Input schema parsing
+//
+// Reads `schema: { format: json, document: { ... } }` from a workflow entry
+// (new format) or the top-level document (old format). Returns undefined if
+// the key is absent or malformed, preserving the existing workflow unchanged.
+// ---------------------------------------------------------------------------
+
+function parseWorkflowSchema(def: RawEntry): JsonSchema | undefined {
+  const schemaRaw = def['schema'];
+  if (!schemaRaw || typeof schemaRaw !== 'object') return undefined;
+  const doc = (schemaRaw as Record<string, unknown>)['document'];
+  if (!doc || typeof doc !== 'object') return undefined;
+  return doc as JsonSchema;
+}
+
 // ---------------------------------------------------------------------------
 // LoopNode
 // ---------------------------------------------------------------------------

src/lib/tasks/schema-paths.ts

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025 - 2026 Zigflow authors <https://github.com/zigflow/studio/graphs/contributors>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Zigflow Visual Editor — Input Schema Path Utilities
+//
+// Pure functions for deriving selectable dot-notation field paths from a
+// JsonSchema. Only `properties` traversal is supported — other JSON Schema
+// keywords are intentionally ignored to keep the Studio simple.
+import type { JsonSchema } from './model';
+
+// ---------------------------------------------------------------------------
+// parseSchemaToPaths
+//
+// Traverses the `properties` tree of a JsonSchema and returns a flat list of
+// dot-notation paths for every leaf and intermediate node.
+//
+// Example:
+//   schema = {
+//     type: 'object',
+//     properties: {
+//       order: {
+//         type: 'object',
+//         properties: { pet: { type: 'object', properties: { id: {} } } }
+//       }
+//     }
+//   }
+//
+// Returns: ['order', 'order.pet', 'order.pet.id']
+// ---------------------------------------------------------------------------
+
+export function parseSchemaToPaths(schema: JsonSchema): string[] {
+  const paths: string[] = [];
+
+  function traverse(s: JsonSchema, prefix: string): void {
+    if (!s.properties) return;
+    for (const [key, child] of Object.entries(s.properties)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      paths.push(path);
+      traverse(child, path);
+    }
+  }
+
+  traverse(schema, '');
+  return paths;
+}
+
+// ---------------------------------------------------------------------------
+// toInputExpression / parseInputExpression
+//
+// Convert between a dot-notation field path and a Zigflow runtime expression.
+//
+// Example:
+//   'order.pet.id'  →  '${ $input.order.pet.id }'
+//   '${ $input.order.pet.id }'  →  'order.pet.id'
+// ---------------------------------------------------------------------------
+
+const INPUT_EXPR_RE =
+  /^\$\{\s*\$input\.([a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+)*)\s*\}$/;
+
+export function toInputExpression(path: string): string {
+  return '${ $input.' + path + ' }';
+}
+
+export function parseInputExpression(value: string): string | null {
+  const m = INPUT_EXPR_RE.exec(value);
+  return m ? (m[1] ?? null) : null;
+}

src/lib/ui/Inspector.svelte

@@ -26,6 +26,7 @@
   } from '$lib/tasks/actions';
   import type {
     ForkNode,
+    JsonSchema,
     NamedWorkflow,
     Node,
     SwitchNode,
@@ -56,6 +57,9 @@
     // Workflow list for switch branch target selection
     workflows?: NamedWorkflow[];
     currentWorkflowName?: string;
+    // Input schema for the active workflow — passed to node editors that
+    // support field-picker UX (e.g. the loop collection field).
+    inputSchema?: JsonSchema | null;
   }
 
   let {
@@ -72,6 +76,7 @@
     onremovebranch,
     workflows = [],
     currentWorkflowName = '',
+    inputSchema = null,
   }: Props = $props();
 
   // ---------------------------------------------------------------------------
@@ -474,7 +479,7 @@
 
     <!-- Task-specific or structural property editor -->
     {#if NodeEditor}
-      <NodeEditor {node} onupdate={(n) => onupdate?.(n)} />
+      <NodeEditor {node} onupdate={(n) => onupdate?.(n)} {inputSchema} />
     {/if}
 
     <!-- Common fields: if + metadata — present on all node types -->