@pikku/core 0.11.0 → 0.11.1

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

@@ -1,4 +1,4 @@
-import type { CoreServices, PikkuInteraction } 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,11 +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 { rpcService } from '../rpc/rpc-runner.js'
+import { CreateWireServices } from '../../types/core.types.js'
 
 /**
  * Error class for queue processor not found
@@ -71,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
@@ -105,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> {
@@ -129,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,
@@ -150,41 +145,24 @@ export async function runQueueJob({
   try {
     logger.info(`Processing job ${job.id} in queue ${job.queueName}`)
 
-    const interaction: PikkuInteraction = { queue }
-    // Use provided singleton services
-    const getAllServices = async () => {
-      const sessionServices = await createSessionServices?.(
-        singletonServices,
-        { queue },
-        undefined
-      )
-
-      const services = rpcService.injectRPCService(
-        {
-          ...singletonServices,
-          ...sessionServices,
-        },
-        interaction,
-        false
-      )
-
-      return services
+    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,
+        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'
 
@@ -147,15 +147,9 @@ export interface QueueWorkers {
  */
 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)
   }
 >
 
@@ -172,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/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,66 +44,60 @@ export class ContextAwareRPCService {
     funcName: string,
     data: In
   ): Promise<Out> {
-    const rpcDepth = this.services.rpc?.depth || 0
+    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>(
-      PikkuWiringTypes.rpc,
+      '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,
-        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: updatedWire,
       }
     )
   }
 
-  public async rpcWithInteraction<In = any, Out = any>(
-    funcName: string,
+  public async rpcWithWire<In = any, Out = any>(
+    rpcName: string,
     data: In,
-    interaction: PikkuInteraction
+    wire: PikkuWire
   ): Promise<Out> {
-    const rpcDepth = this.services.rpc?.depth || 0
-    const mergedInteraction = {
-      ...this.interaction,
-      ...interaction,
+    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,
-      funcName,
-      getPikkuFunctionName(funcName),
+      '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,
-            ...mergedInteraction,
-          }
-        },
         data: () => data,
-        userSession: this.services.userSession,
         coerceDataFromSchema: this.options.coerceDataFromSchema,
-        interaction: mergedInteraction,
+        wire: mergedWire,
       }
     )
   }
@@ -140,28 +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),
-      rpcWithInteraction: serviceRPC.rpcWithInteraction.bind(serviceRPC),
+      rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
     } as any
-    return serviceCopy as Services & { rpc: TypedRPC }
   }
 }