@pikku/core 0.10.2 → 0.11.1

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

@@ -1,4 +1,4 @@
-import type { CoreServices } from '../../types/core.types.js'
+import type { CoreServices, PikkuWire } from '../../types/core.types.js'
 import type { CoreQueueWorker, QueueJob, PikkuQueue } from './queue.types.js'
 import type {
   CorePikkuFunctionConfig,
@@ -7,10 +7,7 @@ import type {
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import {
-  CreateSessionServices,
-  PikkuWiringTypes,
-} from '../../types/core.types.js'
+import { CreateWireServices } from '../../types/core.types.js'
 
 /**
  * Error class for queue processor not found
@@ -70,7 +67,6 @@ export const wireQueueWorker = <
     permissions: queueWorker.func.permissions,
     middleware: queueWorker.func.middleware as any,
     tags: queueWorker.func.tags,
-    docs: queueWorker.func.docs as any,
   })
 
   // Store processor definition in state - runtime adapters will pick this up
@@ -104,12 +100,12 @@ export async function removeQueueWorker(name: string): Promise<void> {
  */
 export async function runQueueJob({
   singletonServices,
-  createSessionServices,
+  createWireServices,
   job,
   updateProgress,
 }: {
   singletonServices: CoreServices
-  createSessionServices?: CreateSessionServices
+  createWireServices?: CreateWireServices
   job: QueueJob
   updateProgress?: (progress: number | string | object) => Promise<void>
 }): Promise<void> {
@@ -128,7 +124,7 @@ export async function runQueueJob({
     throw new Error(`Queue worker registration not found for: ${job.queueName}`)
   }
 
-  // Create the queue interaction object
+  // Create the queue wire object
   const queue: PikkuQueue = {
     queueName: job.queueName,
     jobId: job.id,
@@ -149,34 +145,24 @@ export async function runQueueJob({
   try {
     logger.info(`Processing job ${job.id} in queue ${job.queueName}`)
 
-    // Use provided singleton services
-    const getAllServices = async () => {
-      const sessionServices = await createSessionServices?.(
-        singletonServices,
-        { queue },
-        undefined
-      )
-
-      return {
-        ...singletonServices,
-        ...sessionServices,
-      }
+    const wire: PikkuWire = {
+      queue,
     }
 
     // Execute the pikku function with the job data
     const result = await runPikkuFunc(
-      PikkuWiringTypes.queue,
+      'queue',
       job.queueName,
       processorMeta.pikkuFuncName,
       {
         singletonServices,
-        getAllServices,
+        createWireServices,
         auth: false,
         data: () => job.data,
         inheritedMiddleware: processorMeta.middleware,
         wireMiddleware: queueWorker.middleware,
         tags: queueWorker.tags,
-        interaction: { queue },
+        wire,
       }
     )
 

package/src/wirings/queue/queue.types.ts

@@ -1,4 +1,4 @@
-import { PikkuDocs, MiddlewareMetadata } from '../../types/core.types.js'
+import { CommonWireMeta } from '../../types/core.types.js'
 import { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 import { QueueConfigMapping } from './validate-worker-config.js'
 
@@ -140,25 +140,16 @@ export interface QueueWorkers {
 
   /** Scan state and register all compatible processors */
   registerQueues(): Promise<Record<string, ConfigValidationResult[]>>
-
-  /** Close all queues and connections */
-  close(): Promise<void>
 }
 
 /**
  * Queue processor metadata
  */
-export type queueWorkersMeta = Record<
+export type QueueWorkersMeta = Record<
   string,
-  {
-    pikkuFuncName: string
-    schemaName?: string
+  CommonWireMeta & {
     queueName: string
-    session?: undefined
-    docs?: PikkuDocs
-    tags?: string[]
     config?: PikkuWorkerConfig
-    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
   }
 >
 
@@ -175,14 +166,13 @@ export type CoreQueueWorker<
   queueName: string
   func: PikkuFunctionConfig
   config?: PikkuWorkerConfig
-  docs?: PikkuDocs
-  session?: undefined
+  errors?: string[]
   tags?: string[]
   middleware?: PikkuFunctionConfig['middleware']
 }
 
 /**
- * Represents a queue interaction object for middleware
+ * Represents a queue wire object for middleware
  * Provides information and actions for the current queue job execution
  */
 export interface PikkuQueue {

package/src/wirings/rpc/index.ts

@@ -1,2 +1,2 @@
-export { initialize, PikkuRPCService } from './rpc-runner.js'
+export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js'
 export type { PikkuRPC, RPCMeta } from './rpc-types.js'

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

@@ -1,8 +1,4 @@
-import {
-  CoreServices,
-  PikkuInteraction,
-  PikkuWiringTypes,
-} from '../../types/core.types.js'
+import { CoreServices, PikkuWire } from '../../types/core.types.js'
 import { runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { ForbiddenError } from '../../errors/errors.js'
@@ -26,7 +22,7 @@ const getPikkuFunctionName = (rpcName: string): string => {
 export class ContextAwareRPCService {
   constructor(
     private services: CoreServices,
-    private interaction: PikkuInteraction,
+    private wire: PikkuWire,
     private options: {
       coerceDataFromSchema?: boolean
       requiresAuth?: boolean
@@ -48,32 +44,77 @@ export class ContextAwareRPCService {
     funcName: string,
     data: In
   ): Promise<Out> {
-    const rpcDepth = this.services.rpc?.depth || 0
-    const pikkuFuncName = getPikkuFunctionName(funcName)
+    const rpcDepth = this.wire.rpc?.depth || 0
+    const updatedWire: PikkuWire = {
+      ...this.wire,
+      rpc: this.wire.rpc
+        ? {
+            ...this.wire.rpc,
+            depth: rpcDepth + 1,
+            global: false,
+          }
+        : undefined,
+    }
+    return runPikkuFunc<In, Out>(
+      'rpc',
+      funcName,
+      getPikkuFunctionName(funcName),
+      {
+        auth: this.options.requiresAuth,
+        // TODO: this is a hack since services have already been created
+        // but is valid since we don't want to keep creating new wire services
+        singletonServices: this.services,
+        data: () => data,
+        coerceDataFromSchema: this.options.coerceDataFromSchema,
+        wire: updatedWire,
+      }
+    )
+  }
+
+  public async rpcWithWire<In = any, Out = any>(
+    rpcName: string,
+    data: In,
+    wire: PikkuWire
+  ): Promise<Out> {
+    const rpcDepth = this.wire.rpc?.depth || 0
+    const mergedWire: PikkuWire = {
+      ...this.wire,
+      ...wire,
+      rpc: this.wire.rpc
+        ? {
+            ...this.wire.rpc,
+            depth: rpcDepth + 1,
+            global: false,
+          }
+        : undefined,
+    }
     return runPikkuFunc<In, Out>(
-      PikkuWiringTypes.rpc,
-      pikkuFuncName,
-      pikkuFuncName,
+      'rpc',
+      rpcName,
+      getPikkuFunctionName(rpcName),
       {
         auth: this.options.requiresAuth,
         singletonServices: this.services,
-        getAllServices: () => {
-          this.services.rpc = this.services.rpc
-            ? ({
-                ...this.services.rpc,
-                depth: rpcDepth + 1,
-                global: false,
-              } as any)
-            : undefined
-          return this.services
-        },
         data: () => data,
-        userSession: this.services.userSession,
         coerceDataFromSchema: this.options.coerceDataFromSchema,
-        interaction: this.interaction,
+        wire: mergedWire,
       }
     )
   }
+
+  public async startWorkflow<In = any>(
+    workflowName: string,
+    input: In
+  ): Promise<{ runId: string }> {
+    if (!this.services.workflowService) {
+      throw new Error('WorkflowService service not available')
+    }
+    return this.services.workflowService.startWorkflow(
+      workflowName,
+      input,
+      this
+    )
+  }
 }
 
 // RPC Service class for the global interface
@@ -89,26 +130,24 @@ export class PikkuRPCService<
   }
 
   // Convenience function for initializing
-  injectRPCService(
+  getContextRPCService(
     services: Services,
-    interaction: PikkuInteraction,
+    wire: PikkuWire,
     requiresAuth?: boolean | undefined,
     depth: number = 0
-  ): Services & { rpc: TypedRPC } {
-    const serviceCopy = {
-      ...services,
-    }
-    const serviceRPC = new ContextAwareRPCService(serviceCopy, interaction, {
+  ): TypedRPC {
+    const serviceRPC = new ContextAwareRPCService(services, wire, {
       coerceDataFromSchema: this.config?.coerceDataFromSchema,
       requiresAuth,
     })
-    serviceCopy.rpc = {
+    return {
       depth,
       global: false,
       invoke: serviceRPC.rpc.bind(serviceRPC),
       invokeExposed: serviceRPC.rpc.bind(serviceRPC),
+      startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
+      rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
     } as any
-    return serviceCopy as Services & { rpc: TypedRPC }
   }
 }
 

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

@@ -7,6 +7,7 @@ export type PikkuRPC<invoke extends Function = any> = {
 export type RPCMeta = {
   pikkuFuncName: string
   expose: boolean
+  internal?: boolean
 }
 
 /**