@pikku/core 0.11.0 → 0.11.2

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
@@ -56,7 +52,7 @@ export const wireQueueWorker = <
   queueWorker: CoreQueueWorker<PikkuFunctionConfig>
 ) => {
   // Get processor metadata
-  const meta = pikkuState('queue', 'meta')
+  const meta = pikkuState(null, 'queue', 'meta')
   const processorMeta = meta[queueWorker.queueName]
   if (!processorMeta) {
     throw new Error(
@@ -71,11 +67,10 @@ 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
-  const registrations = pikkuState('queue', 'registrations')
+  const registrations = pikkuState(null, 'queue', 'registrations')
   registrations.set(queueWorker.queueName, queueWorker)
 }
 
@@ -83,14 +78,14 @@ export const wireQueueWorker = <
  * Get all registered queue processors
  */
 export function getQueueWorkers(): Map<string, CoreQueueWorker> {
-  return pikkuState('queue', 'registrations')
+  return pikkuState(null, 'queue', 'registrations')
 }
 
 /**
  * Stop and remove a queue processor
  */
 export async function removeQueueWorker(name: string): Promise<void> {
-  const registrations = pikkuState('queue', 'registrations')
+  const registrations = pikkuState(null, 'queue', 'registrations')
   const registration = registrations.get(name)
 
   if (!registration) {
@@ -105,31 +100,31 @@ 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> {
   const logger = singletonServices.logger
 
-  const meta = pikkuState('queue', 'meta')
+  const meta = pikkuState(null, 'queue', 'meta')
   const processorMeta = meta[job.queueName]
   if (!processorMeta) {
     throw new Error(`Processor metadata not found for: ${job.queueName}`)
   }
 
   // Get the queue worker registration to access middleware
-  const registrations = pikkuState('queue', 'registrations')
+  const registrations = pikkuState(null, 'queue', 'registrations')
   const queueWorker = registrations.get(job.queueName)
   if (!queueWorker) {
     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/index.ts

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

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

@@ -1,20 +1,38 @@
-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'
-import { PikkuRPC } from './rpc-types.js'
+import { PikkuRPC, ResolvedFunction } from './rpc-types.js'
 
-// Type for the RPC service configuration
-type RPCServiceConfig = {
-  coerceDataFromSchema: boolean
+/**
+ * Resolve a namespaced function reference to package and function names
+ * Uses pikkuState to look up the namespace -> package mapping
+ */
+const resolveNamespace = (
+  namespacedFunction: string
+): ResolvedFunction | null => {
+  const colonIndex = namespacedFunction.indexOf(':')
+  if (colonIndex === -1) {
+    return null
+  }
+
+  const namespace = namespacedFunction.substring(0, colonIndex)
+  const functionName = namespacedFunction.substring(colonIndex + 1)
+
+  const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
+  const packageName = externalPackages.get(namespace)
+  if (!packageName) {
+    return null
+  }
+
+  return {
+    package: packageName,
+    function: functionName,
+  }
 }
 
 const getPikkuFunctionName = (rpcName: string): string => {
-  const rpc = pikkuState('rpc', 'meta')
+  const rpc = pikkuState(null, 'rpc', 'meta')
   const rpcMeta = rpc[rpcName]
   if (!rpcMeta) {
     throw new Error(`RPC function not found: ${rpcName}`)
@@ -26,15 +44,14 @@ const getPikkuFunctionName = (rpcName: string): string => {
 export class ContextAwareRPCService {
   constructor(
     private services: CoreServices,
-    private interaction: PikkuInteraction,
+    private wire: PikkuWire,
     private options: {
-      coerceDataFromSchema?: boolean
       requiresAuth?: boolean
     }
   ) {}
 
   public async rpcExposed(funcName: string, data: any): Promise<any> {
-    const functionMeta = pikkuState('function', 'meta')[funcName]
+    const functionMeta = pikkuState(null, 'function', 'meta')[funcName]
     if (!functionMeta) {
       throw new Error(`Function not found: ${funcName}`)
     }
@@ -48,66 +65,118 @@ 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,
+    }
+
+    // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+    if (funcName.includes(':')) {
+      return this.invokeExternalPackageFunction<In, Out>(
+        funcName,
+        data,
+        updatedWire
+      )
+    }
+
+    // Main package function
     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,
+  /**
+   * Invoke a function from an external package
+   * External packages register their functions in pikkuState under their package name.
+   * The function is executed using the parent services (shared singleton services).
+   * @private
+   */
+  private async invokeExternalPackageFunction<In = any, Out = any>(
+    namespacedFunction: string,
+    data: In,
+    wire: PikkuWire
+  ): Promise<Out> {
+    // 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 externalPackages config.`
+      )
+    }
+
+    // Get the function meta from the external package
+    // External packages use function meta, not RPC meta
+    const externalFunctionMeta = pikkuState(
+      resolved.package,
+      'function',
+      'meta'
+    )
+    const funcMeta = externalFunctionMeta[resolved.function]
+    if (!funcMeta) {
+      throw new Error(
+        `Function '${resolved.function}' not found in package '${resolved.package}'. ` +
+          `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`
+      )
+    }
+    const funcName = funcMeta.pikkuFuncName || resolved.function
+
+    // Execute the function using runPikkuFunc with the external package's state
+    // We use the parent services (this.services) since external packages share services
+    // Pass the function's tags so tag-based middleware/permissions are applied
+    return runPikkuFunc<In, Out>('rpc', namespacedFunction, funcName, {
+      auth: this.options.requiresAuth,
+      singletonServices: this.services,
+      data: () => data,
+      wire,
+      packageName: resolved.package,
+      tags: funcMeta.tags,
+    })
+  }
+
+  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,
       }
     )
   }
@@ -132,43 +201,26 @@ export class PikkuRPCService<
   Services extends CoreServices,
   TypedRPC = PikkuRPC,
 > {
-  private config?: RPCServiceConfig
-
-  // Initialize the RPC service with configuration
-  initialize(config: RPCServiceConfig) {
-    this.config = config
-  }
-
   // 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, {
-      coerceDataFromSchema: this.config?.coerceDataFromSchema,
+  ): TypedRPC {
+    const serviceRPC = new ContextAwareRPCService(services, wire, {
       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 }
   }
 }
 
 // Create a singleton instance
 export const rpcService = new PikkuRPCService()
-
-// Convenience function for initializing
-export const initialize = (config: RPCServiceConfig) => {
-  rpcService.initialize(config)
-}

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

@@ -17,3 +17,11 @@ export interface RPCHandler<Input, Output> {
   input: Input
   output: Output
 }
+
+/**
+ * Resolved function reference from namespace
+ */
+export interface ResolvedFunction {
+  package: string
+  function: string
+}

package/src/wirings/scheduler/log-schedulers.ts

@@ -6,7 +6,7 @@ import { Logger } from '../../services/index.js'
  * @param logger - A logger for logging information.
  */
 export const logSchedulers = (logger: Logger) => {
-  const scheduledTasks = pikkuState('scheduler', 'tasks')
+  const scheduledTasks = pikkuState(null, 'scheduler', 'tasks')
   if (scheduledTasks.size === 0) {
     logger.info('No scheduled tasks added')
     return