@pikku/core 0.11.0 → 0.11.1

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

@@ -1,18 +1,16 @@
 import {
-  PikkuInteraction,
-  PikkuWiringTypes,
+  PikkuWire,
   type CoreServices,
   type CoreSingletonServices,
   type CoreUserSession,
-  type CreateSessionServices,
+  type CreateWireServices,
 } from '../../types/core.types.js'
 import type { CoreScheduledTask } from './scheduler.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
-import { closeSessionServices } from '../../utils.js'
+import { closeWireServices } from '../../utils.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { rpcService } from '../rpc/rpc-runner.js'
-import { PikkuUserSessionService } from '../../services/user-session-service.js'
+import { PikkuSessionService } from '../../services/user-session-service.js'
 import {
   CorePikkuFunctionConfig,
   CorePikkuFunctionSessionless,
@@ -22,7 +20,7 @@ export type RunScheduledTasksParams = {
   name: string
   session?: CoreUserSession
   singletonServices: CoreSingletonServices
-  createSessionServices?: CreateSessionServices<
+  createWireServices?: CreateWireServices<
     CoreSingletonServices,
     CoreServices<CoreSingletonServices>,
     CoreUserSession
@@ -45,9 +43,8 @@ export const wireScheduler = <
     func: scheduledTask.func.func,
     auth: scheduledTask.func.auth,
     permissions: scheduledTask.func.permissions,
-    middleware: scheduledTask.func.middleware as any,
+    middleware: scheduledTask.func.middleware,
     tags: scheduledTask.func.tags,
-    docs: scheduledTask.func.docs as any,
   })
 
   const tasks = pikkuState('scheduler', 'tasks')
@@ -76,13 +73,13 @@ export async function runScheduledTask({
   name,
   session,
   singletonServices,
-  createSessionServices,
+  createWireServices,
 }: RunScheduledTasksParams): Promise<void> {
-  let sessionServices: any
+  let wireServices: any
   const task = pikkuState('scheduler', 'tasks').get(name)
   const meta = pikkuState('scheduler', 'meta')[name]
 
-  const userSession = new PikkuUserSessionService()
+  const userSession = new PikkuSessionService()
   if (session) {
     userSession.set(session)
   }
@@ -96,8 +93,8 @@ export async function runScheduledTask({
     )
   }
 
-  // Create the scheduled task interaction object
-  const interaction: PikkuInteraction = {
+  // Create the scheduled task wire object
+  const wire: PikkuWire = {
     scheduledTask: {
       name,
       schedule: task.schedule,
@@ -106,6 +103,7 @@ export async function runScheduledTask({
         throw new ScheduledTaskSkippedError(name, reason)
       },
     },
+    session: userSession,
   }
 
   try {
@@ -113,40 +111,16 @@ export async function runScheduledTask({
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
-    const getAllServices = async () => {
-      sessionServices = await createSessionServices?.(
-        singletonServices,
-        interaction,
-        session
-      )
-
-      return rpcService.injectRPCService(
-        {
-          ...singletonServices,
-          ...sessionServices,
-        },
-        interaction
-      )
-    }
-
-    const result = await runPikkuFunc(
-      PikkuWiringTypes.scheduler,
-      meta.name,
-      meta.pikkuFuncName,
-      {
-        singletonServices,
-        getAllServices,
-        userSession,
-        auth: false,
-        data: () => undefined,
-        inheritedMiddleware: meta.middleware,
-        wireMiddleware: task.middleware,
-        tags: task.tags,
-        interaction,
-      }
-    )
-
-    return result
+    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
+      singletonServices,
+      createWireServices,
+      auth: false,
+      data: () => undefined,
+      inheritedMiddleware: meta.middleware,
+      wireMiddleware: task.middleware,
+      tags: task.tags,
+      wire,
+    })
   } catch (e: any) {
     const errorResponse = getErrorResponse(e)
     if (errorResponse != null) {
@@ -154,8 +128,8 @@ export async function runScheduledTask({
     }
     throw e
   } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
+    if (wireServices) {
+      await closeWireServices(singletonServices.logger, wireServices)
     }
   }
 }

package/src/wirings/scheduler/scheduler.types.ts

@@ -1,8 +1,7 @@
 import {
-  PikkuDocs,
   CoreUserSession,
   CorePikkuMiddleware,
-  MiddlewareMetadata,
+  CommonWireMeta,
 } from '../../types/core.types.js'
 import {
   CorePikkuFunctionConfig,
@@ -15,14 +14,10 @@ import {
 export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> =
   Record<
     string,
-    {
-      pikkuFuncName: string
+    CommonWireMeta & {
       name: string
       schedule: string
       session?: UserSession
-      docs?: PikkuDocs
-      tags?: string[]
-      middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
     }
   >
 
@@ -38,13 +33,12 @@ export type CoreScheduledTask<
   name: string
   schedule: string
   func: PikkuFunctionConfig
-  docs?: PikkuDocs
   tags?: string[]
   middleware?: PikkuMiddleware[]
 }
 
 /**
- * Represents a scheduled task interaction object for middleware
+ * Represents a scheduled task wire object for middleware
  * Provides information about the current scheduled task execution
  */
 export interface PikkuScheduledTask {

package/src/wirings/workflow/index.ts

@@ -7,7 +7,17 @@ export type {
   CoreWorkflow,
   WorkflowStepOptions,
   WorkflowStepMeta,
-  PikkuWorkflowInteraction,
+  RpcStepMeta,
+  BranchStepMeta,
+  ParallelGroupStepMeta,
+  FanoutStepMeta,
+  ReturnStepMeta,
+  InlineStepMeta,
+  SleepStepMeta,
+  CancelStepMeta,
+  InputSource,
+  OutputBinding,
+  PikkuWorkflowWire,
   PikkuWorkflow,
   WorkflowsMeta,
   WorkflowRun,
@@ -18,5 +28,16 @@ export type {
 
 export { PikkuWorkflowService } from './pikku-workflow-service.js'
 
-// Functions
-export { wireWorkflow } from './workflow-runner.js'
+// Internal registration function (used by generated code)
+export { addWorkflow } from './workflow-runner.js'
+
+/**
+ * @deprecated This function is no longer used and will be removed in a future release.
+ * It exists only for backwards compatibility with generated code.
+ * TODO: Remove this export in a future release after updating code generation
+ */
+export const wireWorkflow = <T extends { name: string; func: any }>(
+  workflow: T
+): void => {
+  // Empty function - no longer used, kept for backwards compatibility
+}

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -3,10 +3,9 @@ import { pikkuState } from '../../pikku-state.js'
 import { getDurationInMilliseconds } from '../../time-utils.js'
 import {
   CoreConfig,
-  CoreServices,
   CoreSingletonServices,
-  CreateSessionServices,
-  PikkuWiringTypes,
+  CreateWireServices,
+  PikkuWire,
   SerializedError,
 } from '../../types/core.types.js'
 import { QueueService } from '../queue/queue.types.js'
@@ -17,7 +16,7 @@ import {
   WorkflowRunNotFound,
 } from './workflow-runner.js'
 import type {
-  PikkuWorkflowInteraction,
+  PikkuWorkflowWire,
   StepState,
   WorkflowRun,
   WorkflowStatus,
@@ -41,17 +40,17 @@ export class WorkflowStepNameNotString extends Error {
 export abstract class PikkuWorkflowService implements WorkflowService {
   private config: WorkflowServiceConfig | undefined
   private singletonServices: CoreSingletonServices | undefined
-  private createSessionServices: CreateSessionServices | undefined
+  private createWireServices: CreateWireServices | undefined
 
   constructor() {}
 
   public setServices(
     singletonServices: CoreSingletonServices,
-    createSessionServices: CreateSessionServices,
+    createWireServices: CreateWireServices,
     { workflow }: CoreConfig
   ) {
     this.singletonServices = singletonServices
-    this.createSessionServices = createSessionServices
+    this.createWireServices = createWireServices
     this.config = {
       retries: workflow?.retries ?? 0,
       retryDelay: workflow?.retryDelay ?? 0,
@@ -176,6 +175,19 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    */
   abstract withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>
 
+  /**
+   * Execute function within a step lock to prevent concurrent step execution
+   * @param runId - Run ID
+   * @param stepName - Step name
+   * @param fn - Function to execute
+   * @returns Function result
+   */
+  abstract withStepLock<T>(
+    runId: string,
+    stepName: string,
+    fn: () => Promise<T>
+  ): Promise<T>
+
   /**
    * Close any open connections
    */
@@ -256,66 +268,42 @@ export abstract class PikkuWorkflowService implements WorkflowService {
   }
 
   public async runWorkflowJob(runId: string, rpcService: any): Promise<void> {
-    // Get the run
     const run = await this.getRun(runId)
     if (!run) {
       throw new WorkflowRunNotFound(runId)
     }
 
-    // Get workflow registration
     const registrations = pikkuState('workflows', 'registrations')
     const workflow = registrations.get(run.workflow)
     if (!workflow) {
       throw new WorkflowNotFoundError(run.workflow)
     }
 
-    // Use lock to prevent concurrent execution
     await this.withRunLock(runId, async () => {
-      // Create workflow interaction object
-      const workflowInteraction = this.createWorkflowInteraction(
+      const meta = pikkuState('workflows', 'meta')
+      const workflowMeta = meta[run.workflow]
+
+      const workflowWire = this.createWorkflowWire(
         run.workflow,
         runId,
         rpcService
       )
-
-      // Get function metadata
-      const meta = pikkuState('workflows', 'meta')
-      const workflowMeta = meta[run.workflow]
-
-      // Execute workflow function with workflow interaction
+      const wire: PikkuWire = { workflow: workflowWire }
       try {
-        const getAllServices = () => {
-          let sessionServices = {}
-          const interaction = { workflow: workflowInteraction }
-          if (this.createSessionServices) {
-            sessionServices = this.createSessionServices(
-              this.singletonServices!,
-              interaction,
-              undefined
-            )
-          }
-          return {
-            ...this.singletonServices,
-            ...sessionServices,
-            ...interaction,
-          } as CoreServices
-        }
         const result = await runPikkuFunc(
-          PikkuWiringTypes.workflow,
+          'workflow',
           workflowMeta.workflowName,
           workflowMeta.pikkuFuncName,
           {
             singletonServices: this.singletonServices!,
-            interaction: { workflow: workflowInteraction },
-            getAllServices,
+            wire,
+            createWireServices: this.createWireServices,
             data: () => run.input,
           }
         )
 
-        // Workflow completed successfully
         await this.updateRunStatus(runId, 'completed', result)
       } catch (error: any) {
-        // Check if it's a WorkflowAsyncException
         if (error instanceof WorkflowAsyncException) {
           // Normal - workflow paused for step execution
           throw error
@@ -327,7 +315,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           throw error
         }
 
-        // Real error - mark as failed
         await this.updateRunStatus(runId, 'failed', undefined, {
           message: error.message,
           stack: error.stack,
@@ -350,64 +337,67 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     data: any,
     rpcService: any
   ): Promise<void> {
-    // Get step state
-    let stepState = await this.getStepState(runId, stepName)
+    // Use step-level lock to prevent concurrent execution of same step
+    await this.withStepLock(runId, stepName, async () => {
+      // Get step state
+      let stepState = await this.getStepState(runId, stepName)
 
-    // Idempotency - if already succeeded, resume orchestrator and return
-    if (stepState.status === 'succeeded') {
-      await this.resumeWorkflow(runId)
-      return
-    }
+      // Idempotency - if already succeeded, resume orchestrator and return
+      if (stepState.status === 'succeeded') {
+        await this.resumeWorkflow(runId)
+        return
+      }
 
-    // Log warning if already running (race condition)
-    if (stepState.status === 'running') {
-      return
-    }
+      // Log warning if already running (race condition)
+      if (stepState.status === 'running') {
+        return
+      }
 
-    // If status is 'failed', this is a retry - create new attempt history
-    if (stepState.status === 'failed') {
-      stepState = await this.createRetryAttempt(stepState.stepId, 'running')
-    }
+      // If status is 'failed', this is a retry - create new attempt history
+      if (stepState.status === 'failed') {
+        stepState = await this.createRetryAttempt(stepState.stepId, 'running')
+      }
 
-    if (stepState.status !== 'pending') {
-      // Mark step as running (pending or failed status)
-      await this.setStepRunning(stepState.stepId)
-    }
+      if (stepState.status !== 'pending') {
+        // Mark step as running (pending or failed status)
+        await this.setStepRunning(stepState.stepId)
+      }
 
-    try {
-      // Execute RPC with workflow step context
-      const result = await rpcService.rpcWithInteraction(rpcName, data, {
-        workflowStep: {
-          runId,
-          stepId: stepState.stepId,
-          attemptCount: stepState.attemptCount,
-        },
-      })
+      try {
+        // Execute RPC with workflow step context
+        const result = await rpcService.rpcWithWire(rpcName, data, {
+          workflowStep: {
+            runId,
+            stepId: stepState.stepId,
+            attemptCount: stepState.attemptCount,
+          },
+        })
 
-      // Store result and mark succeeded
-      await this.setStepResult(stepState.stepId, result)
+        // Store result and mark succeeded
+        await this.setStepResult(stepState.stepId, result)
 
-      // Resume orchestrator to continue workflow
-      try {
-        await this.resumeWorkflow(runId)
-      } catch (resumeError: any) {
-        throw resumeError
-      }
-    } catch (error: any) {
-      // Store error and mark failed
-      await this.setStepError(stepState.stepId, error)
+        // Resume orchestrator to continue workflow
+        try {
+          await this.resumeWorkflow(runId)
+        } catch (resumeError: any) {
+          throw resumeError
+        }
+      } catch (error: any) {
+        // Store error and mark failed
+        await this.setStepError(stepState.stepId, error)
 
-      const maxAttempts = (stepState.retries ?? 0) + 1
-      const retriesExhausted = stepState.attemptCount >= maxAttempts
+        const maxAttempts = (stepState.retries ?? 0) + 1
+        const retriesExhausted = stepState.attemptCount >= maxAttempts
 
-      if (retriesExhausted) {
-        // No more retries - resume orchestrator to mark workflow as failed
-        await this.resumeWorkflow(runId)
-      }
+        if (retriesExhausted) {
+          // No more retries - resume orchestrator to mark workflow as failed
+          await this.resumeWorkflow(runId)
+        }
 
-      // Always throw so queue knows the job failed and can retry if needed
-      throw error
-    }
+        // Always throw so queue knows the job failed and can retry if needed
+        throw error
+      }
+    })
   }
 
   /**
@@ -531,7 +521,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       const attemptCount = stepState.attemptCount
 
       try {
-        const result = await rpcService.rpcWithInteraction(rpcName, data, {
+        const result = await rpcService.rpcWithWire(rpcName, data, {
           workflowStep: {
             runId,
             stepId: stepState.stepId,
@@ -686,12 +676,12 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     throw new WorkflowCancelledException(runId, reason)
   }
 
-  private createWorkflowInteraction(
+  private createWorkflowWire(
     workflowName: string,
     runId: string,
     rpcService: any
-  ): PikkuWorkflowInteraction {
-    const workflowInteraction: PikkuWorkflowInteraction = {
+  ): PikkuWorkflowWire {
+    const workflowWire: PikkuWorkflowWire = {
       workflowName,
       runId,
       getRun: async () => (await this.getRun(runId)) as WorkflowRun,
@@ -738,7 +728,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         await this.cancelWorkflow(runId, reason)
       },
     }
-    return workflowInteraction
+    return workflowWire
   }
 
   private verifyStepName(stepName: string) {

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

@@ -1,5 +1,3 @@
-import type { CoreWorkflow } from './workflow.types.js'
-import type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuError } from '../../errors/error-handler.js'
 import { addFunction } from '../../function/function-runner.js'
@@ -49,37 +47,26 @@ export class WorkflowRunNotFound extends PikkuError {
 }
 
 /**
- * Register a workflow with the system
+ * Add a workflow to the system
+ * This is called by the generated workflow wirings
  */
-export const wireWorkflow = <
-  PikkuFunctionConfig extends CorePikkuFunctionConfig<
-    any,
-    any,
-    any
-  > = CorePikkuFunctionConfig<any, any, any>,
->(
-  workflow: CoreWorkflow<PikkuFunctionConfig>
-) => {
+export const addWorkflow = (workflowName: string, workflowFunc: any) => {
   // Get workflow metadata from inspector
   const meta = pikkuState('workflows', 'meta')
-  const workflowMeta = meta[workflow.name]
+  const workflowMeta = meta[workflowName]
   if (!workflowMeta) {
     throw new Error(
-      `Workflow metadata not found for '${workflow.name}'. Make sure to run the CLI to generate metadata.`
+      `Workflow metadata not found for '${workflowName}'. Make sure to run the CLI to generate metadata.`
     )
   }
 
-  // Register the function with pikku
-  addFunction(workflowMeta.pikkuFuncName, {
-    func: workflow.func.func,
-    auth: workflow.func.auth,
-    permissions: workflow.func.permissions,
-    middleware: workflow.func.middleware as any,
-    tags: workflow.func.tags,
-    docs: workflow.func.docs as any,
-  })
-
   // Store workflow definition in state
   const registrations = pikkuState('workflows', 'registrations')
-  registrations.set(workflow.name, workflow)
+  registrations.set(workflowName, {
+    name: workflowName,
+    func: workflowFunc,
+  })
+
+  // Register the function with pikku
+  addFunction(workflowMeta.pikkuFuncName, workflowFunc)
 }