@pikku/core 0.11.0 → 0.11.2

package/src/function/function-runner.test.ts

@@ -3,11 +3,7 @@ import * as assert from 'node:assert'
 import { addFunction, runPikkuFunc } from './function-runner.js'
 import { addMiddleware, addPermission } from '../index.js'
 import { resetPikkuState, pikkuState } from '../pikku-state.js'
-import {
-  CoreServices,
-  CorePikkuMiddleware,
-  PikkuWiringTypes,
-} from '../types/core.types.js'
+import { CoreServices, CorePikkuMiddleware } from '../types/core.types.js'
 import { CorePermissionGroup } from './functions.types.js'
 
 beforeEach(() => {
@@ -25,7 +21,7 @@ const addTestFunction = (funcName: string, funcConfig: any) => {
   const permissions = funcConfig.tags
     ? funcConfig.tags.map((tag: string) => ({ type: 'tag' as const, tag }))
     : undefined
-  pikkuState('function', 'meta')[funcName] = {
+  pikkuState(null, 'function', 'meta')[funcName] = {
     pikkuFuncName: funcName,
     inputSchemaName: null,
     outputSchemaName: null,
@@ -51,7 +47,7 @@ describe('runPikkuFunc - Integration Tests', () => {
   test('should execute middleware in correct order: wiringTags → wiringMiddleware → funcTags → funcMiddleware', async () => {
     const executionOrder: string[] = []
     const createMiddleware = (name: string): CorePikkuMiddleware => {
-      return async (services, interaction, next) => {
+      return async (services, wire, next) => {
         executionOrder.push(name)
         await next()
       }
@@ -71,7 +67,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'testFunc',
       {
@@ -81,7 +77,7 @@ describe('runPikkuFunc - Integration Tests', () => {
         wireMiddleware: [createMiddleware('wiringMiddleware')],
         inheritedMiddleware: [{ type: 'tag', tag: 'wiringTag' }],
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
@@ -141,7 +137,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'testFunc',
       {
@@ -151,7 +147,7 @@ describe('runPikkuFunc - Integration Tests', () => {
         wirePermissions: wiringPermissions,
         tags: ['wiringTag'],
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
@@ -176,13 +172,13 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+      runPikkuFunc('rpc', Math.random().toString(), 'testFunc', {
         singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
         data: () => ({}),
         tags: ['wiringTag'],
         auth: false,
-        interaction: {},
+        wire: {},
       }),
       {
         message: 'Permission denied',
@@ -200,13 +196,13 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+      runPikkuFunc('rpc', Math.random().toString(), 'testFunc', {
         singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
         data: () => ({}),
         wirePermissions: wiringPermissions,
         auth: false,
-        interaction: {},
+        wire: {},
       }),
       {
         message: 'Permission denied',
@@ -225,12 +221,12 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+      runPikkuFunc('rpc', Math.random().toString(), 'testFunc', {
         singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
         data: () => ({}),
         auth: false,
-        interaction: {},
+        wire: {},
       }),
       {
         message: 'Permission denied',
@@ -249,12 +245,12 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+      runPikkuFunc('rpc', Math.random().toString(), 'testFunc', {
         singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
         data: () => ({}),
         auth: false,
-        interaction: {},
+        wire: {},
       }),
       {
         message: 'Permission denied',
@@ -267,7 +263,7 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     const duplicatedMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       executionCount++
@@ -283,18 +279,13 @@ describe('runPikkuFunc - Integration Tests', () => {
       tags: ['testTag'], // Same middleware via tag
     })
 
-    await runPikkuFunc(
-      PikkuWiringTypes.rpc,
-      Math.random().toString(),
-      'testFunc',
-      {
-        singletonServices: mockSingletonServices,
-        getAllServices: () => mockServices,
-        data: () => ({}),
-        auth: false,
-        interaction: {},
-      }
-    )
+    await runPikkuFunc('rpc', Math.random().toString(), 'testFunc', {
+      singletonServices: mockSingletonServices,
+      getAllServices: () => mockServices,
+      data: () => ({}),
+      auth: false,
+      wire: {},
+    })
 
     // Should only execute once due to deduplication
     assert.equal(executionCount, 1)
@@ -336,7 +327,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'testFunc',
       {
@@ -344,7 +335,7 @@ describe('runPikkuFunc - Integration Tests', () => {
         getAllServices: () => mockServices,
         data: () => ({}),
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
@@ -364,7 +355,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'simpleFunc',
       {
@@ -372,7 +363,7 @@ describe('runPikkuFunc - Integration Tests', () => {
         getAllServices: () => mockServices,
         data: () => ({}),
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
@@ -384,7 +375,7 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     const wiringMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       executionOrder.push('wiringMiddleware')
@@ -408,7 +399,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'testFunc',
       {
@@ -418,7 +409,7 @@ describe('runPikkuFunc - Integration Tests', () => {
         wireMiddleware: [wiringMiddleware],
         wirePermissions: wiringPermissions,
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
@@ -436,7 +427,7 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     const funcMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       executionOrder.push('funcMiddleware')
@@ -462,7 +453,7 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'testFunc',
       {
@@ -470,7 +461,7 @@ describe('runPikkuFunc - Integration Tests', () => {
         getAllServices: () => mockServices,
         data: () => ({}),
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
@@ -486,69 +477,67 @@ describe('runPikkuFunc - Integration Tests', () => {
   test('should pass correct parameters to function', async () => {
     let receivedServices: any
     let receivedData: any
-    let receivedSession: any
+    let receivedWire: any
 
     const testData = { test: 'data' }
-    const testSession = { userId: 'test-user' }
 
     addTestFunction('testFunc', {
-      func: async (services, data, session) => {
+      func: async (services, data, wire) => {
         receivedServices = services
         receivedData = data
-        receivedSession = session
+        receivedWire = wire
         return 'success'
       },
     })
 
-    await runPikkuFunc(
-      PikkuWiringTypes.rpc,
-      Math.random().toString(),
-      'testFunc',
-      {
-        singletonServices: mockSingletonServices,
-        getAllServices: () => mockServices,
-        data: () => testData,
-        userSession: { get: () => testSession, set: () => {} } as any,
-        auth: false,
-        interaction: {},
-      }
-    )
+    await runPikkuFunc('rpc', Math.random().toString(), 'testFunc', {
+      singletonServices: mockServices,
+      data: () => testData,
+      auth: false,
+      wire: { rpc: {} },
+    })
 
-    assert.equal(receivedServices, mockServices)
+    assert.deepEqual(receivedServices, mockServices)
     assert.equal(receivedData, testData)
-    assert.equal(receivedSession, testSession)
+    // Check that wire has rpc service and session
+    assert.ok(receivedWire.rpc)
+    assert.equal(receivedWire.session, undefined)
   })
 
-  test('should handle async getAllServices function', async () => {
+  test('should handle async createWireServices function', async () => {
     let servicesProvided: any
+    const wireServices = { customService: 'value' }
 
     addTestFunction('testFunc', {
-      func: async (services) => {
+      func: async (services, data, wire) => {
         servicesProvided = services
         return 'success'
       },
     })
 
-    const asyncGetServices = async () => {
+    const asyncCreateWireServices = async () => {
       // Simulate async service creation
       await new Promise((resolve) => setTimeout(resolve, 1))
-      return mockServices
+      return wireServices
     }
 
     const result = await runPikkuFunc(
-      PikkuWiringTypes.rpc,
+      'rpc',
       Math.random().toString(),
       'testFunc',
       {
         singletonServices: mockSingletonServices,
-        getAllServices: asyncGetServices,
+        createWireServices: asyncCreateWireServices,
         data: () => ({}),
         auth: false,
-        interaction: {},
+        wire: {},
       }
     )
 
     assert.equal(result, 'success')
-    assert.equal(servicesProvided, mockServices)
+    assert.deepEqual(servicesProvided, {
+      ...mockSingletonServices,
+      ...wireServices,
+    })
   })
 })

package/src/function/function-runner.ts

@@ -7,37 +7,94 @@ import {
   CoreUserSession,
   CorePikkuMiddleware,
   PikkuWiringTypes,
-  CoreSingletonServices,
-  PikkuInteraction,
+  PikkuWire,
   MiddlewareMetadata,
   PermissionMetadata,
+  CoreSingletonServices,
+  CreateWireServices,
+  CoreConfig,
 } from '../types/core.types.js'
 import {
   CorePermissionGroup,
   CorePikkuFunctionConfig,
   CorePikkuPermission,
 } from './functions.types.js'
-import { UserSessionService } from '../services/user-session-service.js'
+import { SessionService } from '../services/user-session-service.js'
 import { ForbiddenError } from '../errors/errors.js'
+import { rpcService } from '../wirings/rpc/rpc-runner.js'
+import { closeWireServices } from '../utils.js'
+
+/**
+ * Get or create singleton services for an external package.
+ * Services are cached in pikkuState to avoid recreation on each call.
+ *
+ * @param packageName - The external package name
+ * @param parentServices - The parent/caller's singleton services (used as base)
+ * @returns The package's singleton services
+ */
+const getOrCreatePackageSingletonServices = async (
+  packageName: string,
+  parentServices: CoreSingletonServices
+): Promise<CoreSingletonServices> => {
+  // Check if we already have cached singleton services for this package
+  const cachedServices = pikkuState(packageName, 'package', 'singletonServices')
+  if (cachedServices) {
+    return cachedServices
+  }
+
+  // Get the package's service factories
+  const factories = pikkuState(packageName, 'package', 'factories')
+  if (!factories || !factories.createSingletonServices) {
+    // No factories registered, use parent services
+    return parentServices
+  }
+
+  // Create config for the package (use parent config if no factory)
+  let config: CoreConfig = parentServices.config
+  if (factories.createConfig) {
+    config = await factories.createConfig(parentServices.variables)
+  }
+
+  // Create singleton services for the package, passing parent services as existing
+  const packageServices = await factories.createSingletonServices(
+    config,
+    parentServices
+  )
+
+  // Cache the services
+  pikkuState(packageName, 'package', 'singletonServices', packageServices)
+
+  return packageServices
+}
 
 export const addFunction = (
   funcName: string,
-  funcConfig: CorePikkuFunctionConfig<any, any>
+  funcConfig: CorePikkuFunctionConfig<any, any>,
+  packageName: string | null = null
 ) => {
-  pikkuState('function', 'functions').set(funcName, funcConfig)
+  pikkuState(packageName, 'function', 'functions').set(funcName, funcConfig)
 }
 
 export const runPikkuFuncDirectly = async <In, Out>(
   funcName: string,
   allServices: CoreServices,
+  wire: PikkuWire,
   data: In,
-  session?: CoreUserSession
+  userSession?: SessionService<CoreUserSession>,
+  packageName: string | null = null
 ) => {
-  const funcConfig = pikkuState('function', 'functions').get(funcName)
+  const funcConfig = pikkuState(packageName, 'function', 'functions').get(
+    funcName
+  )
   if (!funcConfig) {
     throw new Error(`Function not found: ${funcName}`)
   }
-  return (await funcConfig.func(allServices, data, session!)) as Out
+  // Inject session into wire
+  const wireWithSession = {
+    ...wire,
+    session: userSession,
+  }
+  return (await funcConfig.func(allServices, data, wireWithSession)) as Out
 }
 
 export const runPikkuFunc = async <In = any, Out = any>(
@@ -45,10 +102,9 @@ export const runPikkuFunc = async <In = any, Out = any>(
   wireId: string,
   funcName: string,
   {
-    getAllServices,
     singletonServices,
+    createWireServices,
     data,
-    userSession,
     auth: wiringAuth,
     inheritedMiddleware,
     wireMiddleware,
@@ -56,13 +112,11 @@ export const runPikkuFunc = async <In = any, Out = any>(
     wirePermissions,
     coerceDataFromSchema,
     tags = [],
-    interaction,
+    wire,
+    packageName = null,
   }: {
     singletonServices: CoreSingletonServices
-    getAllServices: (
-      session?: CoreUserSession
-    ) => Promise<CoreServices> | CoreServices
-    userSession?: UserSessionService<CoreUserSession>
+    createWireServices?: CreateWireServices
     data: () => Promise<In> | In
     auth?: boolean
     inheritedMiddleware?: MiddlewareMetadata[]
@@ -71,18 +125,36 @@ export const runPikkuFunc = async <In = any, Out = any>(
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[]
     coerceDataFromSchema?: boolean
     tags?: string[]
-    interaction: PikkuInteraction
+    wire: PikkuWire
+    packageName?: string | null
   }
 ): Promise<Out> => {
-  const funcConfig = pikkuState('function', 'functions').get(funcName)
+  const funcConfig = pikkuState(packageName, 'function', 'functions').get(
+    funcName
+  )
   if (!funcConfig) {
     throw new Error(`Function not found: ${funcName}`)
   }
-  const funcMeta = pikkuState('function', 'meta')[funcName]
+  const allMeta = pikkuState(packageName, 'function', 'meta')
+  const funcMeta = allMeta[funcName]
   if (!funcMeta) {
     throw new Error(`Function meta not found: ${funcName}`)
   }
 
+  // For external packages, get or create their singleton services
+  const resolvedSingletonServices = packageName
+    ? await getOrCreatePackageSingletonServices(packageName, singletonServices)
+    : singletonServices
+
+  // Get the package's createWireServices if available
+  let resolvedCreateWireServices = createWireServices
+  if (packageName) {
+    const factories = pikkuState(packageName, 'package', 'factories')
+    if (factories?.createWireServices) {
+      resolvedCreateWireServices = factories.createWireServices
+    }
+  }
+
   // Convert tags to PermissionMetadata and merge with inheritedPermissions
   const mergedInheritedPermissions: PermissionMetadata[] = [
     ...(inheritedPermissions || []),
@@ -91,16 +163,23 @@ export const runPikkuFunc = async <In = any, Out = any>(
 
   // Helper function to run permissions and execute the function
   const executeFunction = async () => {
-    const session = await userSession?.get()
+    const initialSession = wire.session?.freezeInitial()
+
+    const wireWithInitialSession: PikkuWire = {
+      ...wire,
+      initialSession,
+    }
+
     if (wiringAuth === true || funcConfig.auth === true) {
       // This means it was explicitly enabled in either wiring or function and has to be respected
-      if (!session) {
+      if (!initialSession) {
         throw new ForbiddenError('Authentication required')
       }
     }
     if (wiringAuth === undefined && funcConfig.auth === undefined) {
       // We always default to requiring auth unless explicitly disabled
-      if (!session) {
+      if (!initialSession) {
+        // TODO: Critical, we need to figure out how to make this work with different wirings
         // throw new ForbiddenError('Authentication required')
       }
     }
@@ -113,48 +192,62 @@ export const runPikkuFunc = async <In = any, Out = any>(
     if (inputSchemaName) {
       // Validate request data against the defined schema, if any
       await validateSchema(
-        singletonServices.logger,
-        singletonServices.schema,
+        resolvedSingletonServices.logger,
+        resolvedSingletonServices.schema,
         inputSchemaName,
-        actualData
+        actualData,
+        packageName
       )
       // Coerce (top level) query string parameters or date objects if specified by the schema
       if (coerceDataFromSchema) {
-        coerceTopLevelDataFromSchema(inputSchemaName, actualData)
+        coerceTopLevelDataFromSchema(inputSchemaName, actualData, packageName)
       }
     }
 
-    const allServices = await getAllServices(session)
-
-    // Run permissions check with combined permissions: inheritedPermissions (including tags) → wirePermissions → funcPermissions
     await runPermissions(wireType, wireId, {
       wireInheritedPermissions: mergedInheritedPermissions,
       wirePermissions: wirePermissions,
       funcInheritedPermissions: funcMeta.permissions,
       funcPermissions: funcConfig.permissions,
-      allServices,
+      services: resolvedSingletonServices,
+      wire: { ...wireWithInitialSession, rpc: undefined } as any,
       data: actualData,
-      session,
+      packageName,
     })
 
-    return await funcConfig.func(allServices, actualData, session!)
+    const wireServices = await resolvedCreateWireServices?.(
+      resolvedSingletonServices,
+      wireWithInitialSession
+    )
+    try {
+      const services = { ...resolvedSingletonServices, ...wireServices }
+      const rpc = rpcService.getContextRPCService(
+        services,
+        wireWithInitialSession
+      )
+      return await funcConfig.func(services, actualData, {
+        ...wireWithInitialSession,
+        rpc,
+      })
+    } finally {
+      if (wireServices) {
+        await closeWireServices(resolvedSingletonServices.logger, wireServices)
+      }
+    }
   }
 
-  // Combine all middleware: inheritedMiddleware → wireMiddleware → funcMiddleware
   const allMiddleware = combineMiddleware(wireType, wireId, {
     wireInheritedMiddleware: inheritedMiddleware,
     wireMiddleware,
     funcInheritedMiddleware: funcMeta.middleware,
     funcMiddleware: funcConfig.middleware,
+    packageName,
   })
 
   if (allMiddleware.length > 0) {
     return (await runMiddleware<CorePikkuMiddleware>(
-      {
-        ...singletonServices,
-        userSession,
-      },
-      interaction,
+      resolvedSingletonServices,
+      wire,
       allMiddleware,
       executeFunction
     )) as Out