@pikku/core 0.11.2 → 0.12.1

package/src/wirings/variable/validate-variable-definitions.test.ts

@@ -0,0 +1,91 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { validateAndBuildVariableDefinitionsMeta } from './validate-variable-definitions.js'
+
+describe('validateAndBuildVariableDefinitionsMeta', () => {
+  test('should build meta from single definition', () => {
+    const definitions = [
+      {
+        name: 'dbUrl',
+        displayName: 'Database URL',
+        description: 'Connection string',
+        variableId: 'DB_URL',
+        sourceFile: 'a.ts',
+      },
+    ]
+    const result = validateAndBuildVariableDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['dbUrl'])
+    assert.strictEqual(result['dbUrl'].variableId, 'DB_URL')
+  })
+
+  test('should allow duplicate variableId with same schema', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'var1',
+        displayName: 'Var 1',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'var2',
+        displayName: 'Var 2',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildVariableDefinitionsMeta(
+      definitions as any,
+      schemaLookup
+    )
+    assert.ok(result['var1'])
+    assert.ok(result['var2'])
+  })
+
+  test('should throw when duplicate variableId has different schemas', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
+      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'var1',
+        displayName: 'Var 1',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'var2',
+        displayName: 'Var 2',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildVariableDefinitionsMeta(
+          definitions as any,
+          schemaLookup
+        ),
+      (err: any) => err.message.includes('different schemas')
+    )
+  })
+
+  test('should handle empty definitions', () => {
+    const result = validateAndBuildVariableDefinitionsMeta([], new Map())
+    assert.deepStrictEqual(result, {})
+  })
+})

package/src/wirings/variable/validate-variable-definitions.ts

@@ -0,0 +1,69 @@
+import type {
+  VariableDefinitions,
+  VariableDefinitionsMeta,
+} from './variable.types.js'
+
+export interface SchemaRefLike {
+  variableName: string
+  sourceFile: string
+}
+
+export function validateAndBuildVariableDefinitionsMeta(
+  definitions: VariableDefinitions,
+  schemaLookup: Map<string, SchemaRefLike>
+): VariableDefinitionsMeta {
+  const meta: VariableDefinitionsMeta = {}
+  const variableIdToDefinition: Map<string, VariableDefinitions[0]> = new Map()
+
+  for (const def of definitions) {
+    const existingDef = variableIdToDefinition.get(def.variableId)
+
+    if (existingDef) {
+      if (def.schema && existingDef.schema) {
+        const defSchemaRef = schemaLookup.get(def.schema as string)
+        const existingSchemaRef = schemaLookup.get(existingDef.schema as string)
+
+        if (defSchemaRef && existingSchemaRef) {
+          if (
+            defSchemaRef.variableName !== existingSchemaRef.variableName ||
+            defSchemaRef.sourceFile !== existingSchemaRef.sourceFile
+          ) {
+            throw new Error(
+              `Variable '${def.variableId}' is defined with different schemas.\n` +
+                `  First definition: ${existingDef.sourceFile} (schema: ${existingSchemaRef.variableName})\n` +
+                `  Second definition: ${def.sourceFile} (schema: ${defSchemaRef.variableName})\n` +
+                `Variables sharing a variableId must use the same schema.`
+            )
+          }
+        }
+      }
+
+      if (!meta[def.name]) {
+        meta[def.name] = {
+          name: def.name,
+          displayName: def.displayName,
+          description: def.description,
+          variableId: def.variableId,
+          schema: def.schema,
+          sourceFile: def.sourceFile,
+        }
+      }
+      continue
+    }
+
+    variableIdToDefinition.set(def.variableId, def)
+
+    if (!meta[def.name]) {
+      meta[def.name] = {
+        name: def.name,
+        displayName: def.displayName,
+        description: def.description,
+        variableId: def.variableId,
+        schema: def.schema,
+        sourceFile: def.sourceFile,
+      }
+    }
+  }
+
+  return meta
+}

package/src/wirings/variable/variable.types.ts

@@ -0,0 +1,22 @@
+export type CoreVariable<T = unknown> = {
+  name: string
+  displayName: string
+  description?: string
+  variableId: string
+  schema: T
+}
+
+export type VariableDefinitionMeta = {
+  name: string
+  displayName: string
+  description?: string
+  variableId: string
+  schema?: Record<string, unknown> | string
+  sourceFile?: string
+}
+
+export type VariableDefinitionsMeta = Record<string, VariableDefinitionMeta>
+
+export type VariableDefinitions = VariableDefinitionMeta[]
+
+export const wireVariable = <T>(_config: CoreVariable<T>): void => {}

package/src/wirings/workflow/dsl/index.ts

@@ -8,6 +8,7 @@ export type {
   WorkflowWireDoRPC,
   WorkflowWireDoInline,
   WorkflowWireSleep,
+  WorkflowWireSuspend,
   InputSource,
   OutputBinding,
   RpcStepMeta,

package/src/wirings/workflow/dsl/workflow-dsl.types.ts

@@ -45,6 +45,11 @@ export type WorkflowWireSleep = (
   duration: string
 ) => Promise<void>
 
+/**
+ * Type signature for workflow.suspend() - used by inspector
+ */
+export type WorkflowWireSuspend = (reason: string) => Promise<void>
+
 /**
  * Input source for step arguments in DSL workflows
  */
@@ -298,7 +303,7 @@ export interface WorkflowStepWire {
  */
 export interface PikkuWorkflowWire {
   /** The workflow name */
-  workflowName: string
+  name: string
   /** The current run ID */
   runId: string
   /** Get the current workflow run */
@@ -309,4 +314,7 @@ export interface PikkuWorkflowWire {
 
   /** Sleep for a duration */
   sleep: WorkflowWireSleep
+
+  /** Suspend workflow until explicitly resumed */
+  suspend: WorkflowWireSuspend
 }

package/src/wirings/workflow/dsl/workflow-runner.ts

@@ -1,5 +1,6 @@
 import { pikkuState } from '../../../pikku-state.js'
 import { addFunction } from '../../../function/function-runner.js'
+import { PikkuMissingMetaError } from '../../../errors/errors.js'
 
 /**
  * Add a workflow to the system
@@ -10,8 +11,8 @@ export const addWorkflow = (workflowName: string, workflowFunc: any) => {
   const meta = pikkuState(null, 'workflows', 'meta')
   const workflowMeta = meta[workflowName]
   if (!workflowMeta) {
-    throw new Error(
-      `Workflow metadata not found for '${workflowName}'. Make sure to run the CLI to generate metadata.`
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for workflow '${workflowName}'`
     )
   }
 
@@ -23,5 +24,5 @@ export const addWorkflow = (workflowName: string, workflowFunc: any) => {
   })
 
   // Register the function with pikku
-  addFunction(workflowMeta.pikkuFuncName, workflowFunc)
+  addFunction(workflowMeta.pikkuFuncId, workflowFunc)
 }

package/src/wirings/workflow/graph/graph-node.ts

@@ -54,7 +54,7 @@ export interface GraphNodeDef<
  * @example
  * ```typescript
  * // Import the typed graph from generated types
- * import { pikkuWorkflowGraph, wireWorkflow } from './.pikku/workflow/pikku-workflow-types.gen.js'
+ * import { pikkuWorkflowGraph } from './.pikku/workflow/pikku-workflow-types.gen.js'
  *
  * export const myGraph = pikkuWorkflowGraph({
  *   name: 'myWorkflow',
@@ -71,11 +71,6 @@ export interface GraphNodeDef<
  *     },
  *   },
  * })
- *
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   graph: myGraph,
- * })
  * ```
  */
 /**