@pikku/core 0.12.14 → 0.12.16

package/src/wirings/rpc/rpc-runner.ts

@@ -7,7 +7,6 @@ import { ForbiddenError } from '../../errors/errors.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import type { PikkuRPC, ResolvedFunction } from './rpc-types.js'
 import { parseVersionedId } from '../../version.js'
-import { encryptJSON } from '../../crypto-utils.js'
 
 export class RPCNotFoundError extends PikkuError {
   public readonly rpcName: string
@@ -118,23 +117,51 @@ export class ContextAwareRPCService {
         : undefined,
     }
 
-    // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+    // Check addon namespace first (e.g. 'stripe:createCharge')
     if (funcName.includes(':')) {
-      return this.invokeAddonFunction<In, Out>(funcName, data, updatedWire)
+      try {
+        return await this.invokeAddonFunction<In, Out>(
+          funcName,
+          data,
+          updatedWire
+        )
+      } catch (addonErr) {
+        if (!(addonErr instanceof RPCNotFoundError)) throw addonErr
+        // Not an addon — fall through to local lookup
+      }
     }
 
-    // Main package function
-    return runPikkuFunc<In, Out>(
-      'rpc',
-      funcName,
-      getPikkuFunctionName(funcName),
-      {
-        auth: this.options.requiresAuth,
-        singletonServices: this.services,
-        data: () => data,
-        wire: updatedWire,
+    // Try local function, then fall back to deployment service (remote)
+    try {
+      return await runPikkuFunc<In, Out>(
+        'rpc',
+        funcName,
+        getPikkuFunctionName(funcName),
+        {
+          auth: this.options.requiresAuth,
+          singletonServices: this.services,
+          data: () => data,
+          wire: updatedWire,
+        }
+      )
+    } catch (e) {
+      if (e instanceof RPCNotFoundError) {
+        // Fall back to deployment service (e.g. CF service binding, Lambda Invoke)
+        if (this.services.deploymentService) {
+          const session =
+            this.wire.getSession && typeof this.wire.getSession === 'function'
+              ? await this.wire.getSession()
+              : (this.wire as any).session
+          return this.services.deploymentService.invoke(
+            funcName,
+            data,
+            session,
+            this.wire.traceId
+          ) as Promise<Out>
+        }
       }
-    )
+      throw e
+    }
   }
 
   /**
@@ -151,10 +178,7 @@ export class ContextAwareRPCService {
     // Resolve namespace to package name
     const resolved = resolveNamespace(namespacedFunction)
     if (!resolved) {
-      throw new Error(
-        `Unknown namespace in function reference: ${namespacedFunction}. ` +
-          `Make sure the package is registered in addons config.`
-      )
+      throw new RPCNotFoundError(namespacedFunction)
     }
 
     // Get the function meta from the addon package
@@ -162,10 +186,7 @@ export class ContextAwareRPCService {
     const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta')
     const funcMeta = addonFunctionMeta[resolved.function]
     if (!funcMeta) {
-      throw new Error(
-        `Function '${resolved.function}' not found in package '${resolved.package}'. ` +
-          `Available functions: ${Object.keys(addonFunctionMeta).join(', ') || '(none)'}`
-      )
+      throw new RPCNotFoundError(namespacedFunction)
     }
     const funcName = funcMeta.pikkuFuncId || resolved.function
 
@@ -210,17 +231,33 @@ export class ContextAwareRPCService {
       return this.invokeAddonFunction<In, Out>(rpcName, data, mergedWire)
     }
 
-    return runPikkuFunc<In, Out>(
-      'rpc',
-      rpcName,
-      getPikkuFunctionName(rpcName),
-      {
-        auth: this.options.requiresAuth,
-        singletonServices: this.services,
-        data: () => data,
-        wire: mergedWire,
+    try {
+      return await runPikkuFunc<In, Out>(
+        'rpc',
+        rpcName,
+        getPikkuFunctionName(rpcName),
+        {
+          auth: this.options.requiresAuth,
+          singletonServices: this.services,
+          data: () => data,
+          wire: mergedWire,
+        }
+      )
+    } catch (e) {
+      if (e instanceof RPCNotFoundError && this.services.deploymentService) {
+        const session =
+          this.wire.getSession && typeof this.wire.getSession === 'function'
+            ? await this.wire.getSession()
+            : (this.wire as any).session
+        return this.services.deploymentService.invoke(
+          rpcName,
+          data,
+          session,
+          this.wire.traceId
+        ) as Promise<Out>
       }
-    )
+      throw e
+    }
   }
 
   public async startWorkflow<In = any>(
@@ -332,94 +369,24 @@ export class ContextAwareRPCService {
     funcName: string,
     data: In
   ): Promise<Out> {
-    let endpoint: string | undefined
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    }
-
-    const colonIndex = funcName.indexOf(':')
-    if (colonIndex !== -1) {
-      const namespace = funcName.substring(0, colonIndex)
-      const addons = pikkuState(null, 'addons', 'packages')
-      const pkgConfig = addons.get(namespace)
-      endpoint = pkgConfig?.rpcEndpoint
-    }
-
-    if (!endpoint && this.services.deploymentService) {
-      const deployments =
-        await this.services.deploymentService.findFunction(funcName)
-      if (deployments.length > 0) {
-        endpoint = deployments[0].endpoint
-      }
-    }
-
-    if (!endpoint) {
+    if (!this.services.deploymentService) {
       throw new Error(
-        `No endpoint configured for remote RPC: ${funcName}. ` +
-          `Configure rpcEndpoint in addons config or set up a DeploymentService.`
-      )
-    }
-
-    let secret: string | undefined
-    if (this.services.secrets) {
-      try {
-        secret = await this.services.secrets.getSecret('PIKKU_REMOTE_SECRET')
-      } catch {}
-    }
-    if (secret) {
-      if (!this.services.jwt) {
-        throw new Error(
-          'PIKKU_REMOTE_SECRET is set but JWT service is not available'
-        )
-      }
-      const session =
-        this.wire.getSession && typeof this.wire.getSession === 'function'
-          ? await this.wire.getSession()
-          : (this.wire as any).session
-      const sessionEnc = session
-        ? await encryptJSON(secret, { session })
-        : undefined
-      const token = await this.services.jwt.encode(
-        { value: 5, unit: 'minute' },
-        {
-          aud: 'pikku-remote',
-          fn: funcName,
-          iat: Date.now(),
-          session: sessionEnc,
-        }
+        `No DeploymentService configured for remote RPC: ${funcName}. ` +
+          `Set up a DeploymentService to enable remote function calls.`
       )
-      headers.Authorization = `Bearer ${token}`
     }
 
-    const url = `${endpoint}/rpc/${encodeURIComponent(funcName)}`
-    const timeoutMs = 30_000
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ data }),
-      signal: AbortSignal.timeout(timeoutMs),
-    })
-
-    if (!response.ok) {
-      let errorBody: string
-      try {
-        errorBody = JSON.stringify(await response.json())
-      } catch {
-        errorBody = await response.text()
-      }
-      throw new Error(
-        `Remote RPC call failed: ${response.status} ${response.statusText}. ${errorBody}`
-      )
-    }
+    const session =
+      this.wire.getSession && typeof this.wire.getSession === 'function'
+        ? await this.wire.getSession()
+        : (this.wire as any).session
 
-    try {
-      return (await response.json()) as Out
-    } catch {
-      const text = await response.text()
-      throw new Error(
-        `Remote RPC call returned non-JSON response: ${response.status} ${response.statusText}. ${text}`
-      )
-    }
+    return this.services.deploymentService.invoke(
+      funcName,
+      data,
+      session,
+      this.wire.traceId
+    ) as Promise<Out>
   }
 }
 

package/src/wirings/scheduler/scheduler-runner.test.ts

@@ -50,7 +50,7 @@ describe('wireScheduler', () => {
     assert.equal(tasks.get('test-task'), mockTask)
   })
 
-  test('should throw error when task metadata not found', () => {
+  test('should skip when scheduled task metadata not found', () => {
     const mockTask: CoreScheduledTask = {
       name: 'missing-meta-task',
       schedule: '0 0 * * *',
@@ -60,16 +60,10 @@ describe('wireScheduler', () => {
       },
     }
 
-    assert.throws(
-      () => wireScheduler(mockTask),
-      (error: any) => {
-        assert.equal(
-          error.message,
-          "Missing generated metadata for scheduled task 'missing-meta-task'"
-        )
-        return true
-      }
-    )
+    wireScheduler(mockTask)
+
+    const tasks = pikkuState(null, 'scheduler', 'tasks')
+    assert.equal(tasks.has('missing-meta-task'), false)
   })
 
   test('should throw error when scheduled task already exists', () => {

package/src/wirings/scheduler/scheduler-runner.ts

@@ -1,7 +1,6 @@
 import type { PikkuWire, CoreUserSession } from '../../types/core.types.js'
 import type { CoreScheduledTask } from './scheduler.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
-import { PikkuMissingMetaError } from '../../errors/errors.js'
 import {
   getSingletonServices,
   getCreateWireServices,
@@ -20,6 +19,8 @@ import type {
 export type RunScheduledTasksParams = {
   name: string
   session?: CoreUserSession
+  /** Pre-resolved trace ID */
+  traceId?: string
 }
 
 export const wireScheduler = <
@@ -32,9 +33,10 @@ export const wireScheduler = <
   const meta = pikkuState(null, 'scheduler', 'meta')
   const taskMeta = meta[scheduledTask.name]
   if (!taskMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for scheduled task '${scheduledTask.name}'`
+    console.warn(
+      `[pikku] Skipping scheduled task '${scheduledTask.name}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
   addFunction(taskMeta.pikkuFuncId, {
     func: scheduledTask.func.func,
@@ -69,9 +71,14 @@ class ScheduledTaskSkippedError extends PikkuError {
 export async function runScheduledTask({
   name,
   session,
+  traceId,
 }: RunScheduledTasksParams): Promise<void> {
   const singletonServices = getSingletonServices()
   const createWireServices = getCreateWireServices()
+  const resolvedTraceId = traceId ?? `cron-${name}-${Date.now()}`
+  const scopedLogger =
+    singletonServices.logger.scope?.(resolvedTraceId) ??
+    singletonServices.logger
   const task = pikkuState(null, 'scheduler', 'tasks').get(name)
   const meta = pikkuState(null, 'scheduler', 'meta')[name]
 
@@ -91,6 +98,7 @@ export async function runScheduledTask({
 
   // Create the scheduled task wire object
   const wire: PikkuWire = {
+    traceId: resolvedTraceId,
     scheduledTask: {
       name,
       schedule: task.schedule,
@@ -103,7 +111,7 @@ export async function runScheduledTask({
   }
 
   try {
-    singletonServices.logger.info(
+    scopedLogger.info(
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
@@ -122,7 +130,7 @@ export async function runScheduledTask({
   } catch (e: any) {
     const errorResponse = getErrorResponse(e)
     if (errorResponse != null) {
-      singletonServices.logger.error(e)
+      scopedLogger.error(e)
     }
     throw e
   }

package/src/wirings/trigger/trigger-runner.test.ts

@@ -7,7 +7,6 @@ import {
   getTriggerMeta,
 } from './trigger-runner.js'
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-import { PikkuMissingMetaError } from '../../errors/errors.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -24,11 +23,11 @@ describe('wireTrigger', () => {
     assert.ok(triggers.has('myTrigger'))
   })
 
-  test('should throw PikkuMissingMetaError when meta is missing', () => {
-    assert.throws(
-      () => wireTrigger({ name: 'noMeta', func: async () => {} } as any),
-      (err: any) => err instanceof PikkuMissingMetaError
-    )
+  test('should skip when trigger metadata not found', () => {
+    wireTrigger({ name: 'noMeta', func: async () => {} } as any)
+
+    const triggers = getRegisteredTriggers()
+    assert.ok(!triggers.has('noMeta'))
   })
 })
 
@@ -43,11 +42,11 @@ describe('wireTriggerSource', () => {
     assert.ok(sources.has('mySource'))
   })
 
-  test('should throw PikkuMissingMetaError when source meta is missing', () => {
-    assert.throws(
-      () => wireTriggerSource({ name: 'noMeta', func: async () => {} } as any),
-      (err: any) => err instanceof PikkuMissingMetaError
-    )
+  test('should skip when trigger source metadata not found', () => {
+    wireTriggerSource({ name: 'noMeta', func: async () => {} } as any)
+
+    const sources = pikkuState(null, 'trigger', 'triggerSources')
+    assert.ok(!sources.has('noMeta'))
   })
 
   test('should throw when trigger source already exists', () => {

package/src/wirings/trigger/trigger-runner.ts

@@ -21,9 +21,10 @@ export const wireTrigger = (trigger: CoreTrigger) => {
   const meta = pikkuState(null, 'trigger', 'meta')
   const triggerMeta = meta[trigger.name]
   if (!triggerMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for trigger '${trigger.name}'`
+    console.warn(
+      `[pikku] Skipping trigger '${trigger.name}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
 
   addFunction(triggerMeta.pikkuFuncId, trigger.func as any)
@@ -43,9 +44,10 @@ export const wireTriggerSource = <TInput = unknown, TOutput = unknown>(
   const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
   const triggerSourceMeta = sourceMeta[source.name]
   if (!triggerSourceMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for trigger source '${source.name}'`
+    console.warn(
+      `[pikku] Skipping trigger source '${source.name}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
 
   const triggerSources = pikkuState(null, 'trigger', 'triggerSources')

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

@@ -1,28 +1,29 @@
 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
  * This is called by the generated workflow wirings
  */
-export const addWorkflow = (workflowName: string, workflowFunc: any) => {
-  // Get workflow metadata from inspector
-  const meta = pikkuState(null, 'workflows', 'meta')
+export const addWorkflow = (
+  workflowName: string,
+  workflowFunc: any,
+  packageName: string | null = null
+) => {
+  const meta = pikkuState(packageName, 'workflows', 'meta')
   const workflowMeta = meta[workflowName]
   if (!workflowMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for workflow '${workflowName}'`
+    console.warn(
+      `[pikku] Skipping workflow '${workflowName}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
 
-  // Store workflow definition in state
-  const registrations = pikkuState(null, 'workflows', 'registrations')
+  const registrations = pikkuState(packageName, 'workflows', 'registrations')
   registrations.set(workflowName, {
     name: workflowName,
     func: workflowFunc,
   })
 
-  // Register the function with pikku
-  addFunction(workflowMeta.pikkuFuncId, workflowFunc)
+  addFunction(workflowMeta.pikkuFuncId, workflowFunc, packageName)
 }

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

@@ -116,8 +116,22 @@ function isTemplate(value: unknown): value is TemplateValue {
 }
 
 function getWorkflowMeta(name: string): WorkflowRuntimeMeta | undefined {
-  const meta = pikkuState(null, 'workflows', 'meta')
-  return meta[name]
+  const rootMeta = pikkuState(null, 'workflows', 'meta')
+  if (rootMeta[name]) return rootMeta[name]
+
+  const colonIndex = name.indexOf(':')
+  if (colonIndex !== -1) {
+    const namespace = name.substring(0, colonIndex)
+    const localName = name.substring(colonIndex + 1)
+    const addons = pikkuState(null, 'addons', 'packages')
+    const pkgConfig = addons?.get(namespace)
+    if (pkgConfig) {
+      const addonMeta = pikkuState(pkgConfig.package, 'workflows', 'meta')
+      if (addonMeta?.[localName]) return addonMeta[localName]
+    }
+  }
+
+  return undefined
 }
 
 function resolveNextFromConfig(next: unknown, branchKey?: string): string[] {
@@ -798,9 +812,10 @@ export async function runWorkflowGraph(
   rpcService?: any,
   inline?: boolean,
   startNode?: string,
-  wire?: WorkflowRunWire
+  wire?: WorkflowRunWire,
+  overrideMeta?: WorkflowRuntimeMeta
 ): Promise<{ runId: string }> {
-  const meta = getWorkflowMeta(graphName)
+  const meta = overrideMeta ?? getWorkflowMeta(graphName)
   if (!meta?.nodes) {
     throw new Error(`Workflow graph '${graphName}' not found`)
   }

package/src/wirings/workflow/index.ts

@@ -20,13 +20,23 @@ export {
   type PikkuWorkflowGraphResult,
 } from './graph/wire-workflow-graph.js'
 
-// Workflow helpers (runtime factories for HTTP handlers)
+// Graph validation and dynamic workflow utilities
 export {
-  workflow,
-  workflowStart,
-  workflowStatus,
-  graphStart,
-} from './workflow-helpers.js'
+  validateWorkflowWiring,
+  computeEntryNodeIds,
+} from './graph/graph-validation.js'
+
+// Queue worker functions (registered by codegen, executed at runtime)
+export {
+  pikkuWorkflowWorkerFunc,
+  pikkuWorkflowOrchestratorFunc,
+  pikkuWorkflowSleeperFunc,
+} from './workflow-queue-workers.js'
+export type {
+  WorkflowStepInput as WorkflowStepQueueInput,
+  PikkuWorkflowOrchestratorInput,
+  PikkuWorkflowSleeperInput,
+} from './workflow-queue-workers.js'
 
 // Re-export all types from workflow.types
 export type {
@@ -37,6 +47,7 @@ export type {
   WorkflowVersionStatus,
   StepStatus,
   WorkflowRun,
+  WorkflowRunStatus,
   StepState,
   WorkflowRunService,
   CoreWorkflow,