@pikku/core 0.10.2 → 0.11.1

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(() => {
@@ -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,18 +7,21 @@ import {
   CoreUserSession,
   CorePikkuMiddleware,
   PikkuWiringTypes,
-  CoreSingletonServices,
-  PikkuInteraction,
+  PikkuWire,
   MiddlewareMetadata,
   PermissionMetadata,
+  CoreSingletonServices,
+  CreateWireServices,
 } 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'
 
 export const addFunction = (
   funcName: string,
@@ -30,14 +33,20 @@ export const addFunction = (
 export const runPikkuFuncDirectly = async <In, Out>(
   funcName: string,
   allServices: CoreServices,
+  wire: PikkuWire,
   data: In,
-  session?: CoreUserSession
+  userSession?: SessionService<CoreUserSession>
 ) => {
   const funcConfig = pikkuState('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 +54,9 @@ export const runPikkuFunc = async <In = any, Out = any>(
   wireId: string,
   funcName: string,
   {
-    getAllServices,
     singletonServices,
+    createWireServices,
     data,
-    userSession,
     auth: wiringAuth,
     inheritedMiddleware,
     wireMiddleware,
@@ -56,13 +64,10 @@ export const runPikkuFunc = async <In = any, Out = any>(
     wirePermissions,
     coerceDataFromSchema,
     tags = [],
-    interaction,
+    wire,
   }: {
     singletonServices: CoreSingletonServices
-    getAllServices: (
-      session?: CoreUserSession
-    ) => Promise<CoreServices> | CoreServices
-    userSession?: UserSessionService<CoreUserSession>
+    createWireServices?: CreateWireServices
     data: () => Promise<In> | In
     auth?: boolean
     inheritedMiddleware?: MiddlewareMetadata[]
@@ -71,7 +76,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[]
     coerceDataFromSchema?: boolean
     tags?: string[]
-    interaction: PikkuInteraction
+    wire: PikkuWire
   }
 ): Promise<Out> => {
   const funcConfig = pikkuState('function', 'functions').get(funcName)
@@ -91,16 +96,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')
       }
     }
@@ -124,23 +136,37 @@ export const runPikkuFunc = async <In = any, Out = any>(
       }
     }
 
-    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: singletonServices,
+      wire: { ...wireWithInitialSession, rpc: undefined } as any,
       data: actualData,
-      session,
     })
 
-    return await funcConfig.func(allServices, actualData, session!)
+    const wireServices = await createWireServices?.(
+      singletonServices,
+      wireWithInitialSession
+    )
+    try {
+      const services = { ...singletonServices, ...wireServices }
+      const rpc = rpcService.getContextRPCService(
+        services,
+        wireWithInitialSession
+      )
+      return await funcConfig.func(services, actualData, {
+        ...wireWithInitialSession,
+        rpc,
+      })
+    } finally {
+      if (wireServices) {
+        await closeWireServices(singletonServices.logger, wireServices)
+      }
+    }
   }
 
-  // Combine all middleware: inheritedMiddleware → wireMiddleware → funcMiddleware
   const allMiddleware = combineMiddleware(wireType, wireId, {
     wireInheritedMiddleware: inheritedMiddleware,
     wireMiddleware,
@@ -150,11 +176,8 @@ export const runPikkuFunc = async <In = any, Out = any>(
 
   if (allMiddleware.length > 0) {
     return (await runMiddleware<CorePikkuMiddleware>(
-      {
-        ...singletonServices,
-        userSession,
-      },
-      interaction,
+      singletonServices,
+      wire,
       allMiddleware,
       executeFunction
     )) as Out

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

@@ -0,0 +1,188 @@
+import { runMiddleware, combineMiddleware } from '../middleware-runner.js'
+import { runPermissions } from '../permissions.js'
+import { pikkuState } from '../pikku-state.js'
+import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
+import {
+  CoreServices,
+  CoreUserSession,
+  CorePikkuMiddleware,
+  PikkuWiringTypes,
+  PikkuWire,
+  MiddlewareMetadata,
+  PermissionMetadata,
+  CoreSingletonServices,
+  CreateWireServices,
+} from '../types/core.types.js'
+import {
+  CorePermissionGroup,
+  CorePikkuFunctionConfig,
+  CorePikkuPermission,
+} from './functions.types.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'
+
+export const addFunction = (
+  funcName: string,
+  funcConfig: CorePikkuFunctionConfig<any, any>
+) => {
+  pikkuState('function', 'functions').set(funcName, funcConfig)
+}
+
+export const runPikkuFuncDirectly = async <In, Out>(
+  funcName: string,
+  allServices: CoreServices,
+  wire: PikkuWire,
+  data: In,
+  userSession?: SessionService<CoreUserSession>
+) => {
+  const funcConfig = pikkuState('function', 'functions').get(funcName)
+  if (!funcConfig) {
+    throw new Error(`Function not found: ${funcName}`)
+  }
+  // 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>(
+  wireType: PikkuWiringTypes,
+  wireId: string,
+  funcName: string,
+  {
+    singletonServices,
+    createWireServices,
+    data,
+    auth: wiringAuth,
+    inheritedMiddleware,
+    wireMiddleware,
+    inheritedPermissions,
+    wirePermissions,
+    coerceDataFromSchema,
+    tags = [],
+    wire,
+  }: {
+    singletonServices: CoreSingletonServices
+    createWireServices?: CreateWireServices
+    data: () => Promise<In> | In
+    auth?: boolean
+    inheritedMiddleware?: MiddlewareMetadata[]
+    wireMiddleware?: CorePikkuMiddleware[]
+    inheritedPermissions?: PermissionMetadata[]
+    wirePermissions?: CorePermissionGroup | CorePikkuPermission[]
+    coerceDataFromSchema?: boolean
+    tags?: string[]
+    wire: PikkuWire
+  }
+): Promise<Out> => {
+  const funcConfig = pikkuState('function', 'functions').get(funcName)
+  if (!funcConfig) {
+    throw new Error(`Function not found: ${funcName}`)
+  }
+  const funcMeta = pikkuState('function', 'meta')[funcName]
+  if (!funcMeta) {
+    throw new Error(`Function meta not found: ${funcName}`)
+  }
+
+  // Convert tags to PermissionMetadata and merge with inheritedPermissions
+  const mergedInheritedPermissions: PermissionMetadata[] = [
+    ...(inheritedPermissions || []),
+    ...(tags?.map((tag) => ({ type: 'tag' as const, tag })) || []),
+  ]
+
+  // Populate initialSession from session.initial
+  const wireWithInitialSession = {
+    ...wire,
+    initialSession: wire.session?.initial,
+  }
+
+  // Helper function to run permissions and execute the function
+  const executeFunction = async () => {
+    const session = wireWithInitialSession.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) {
+        throw new ForbiddenError('Authentication required')
+      }
+    }
+    if (wiringAuth === undefined && funcConfig.auth === undefined) {
+      // We always default to requiring auth unless explicitly disabled
+      if (!session) {
+        // throw new ForbiddenError('Authentication required')
+      }
+    }
+
+    // Evaluate the data from the lazy function
+    const actualData = await data()
+
+    // Validate and coerce data if schema is defined
+    const inputSchemaName = funcMeta.inputSchemaName
+    if (inputSchemaName) {
+      // Validate request data against the defined schema, if any
+      await validateSchema(
+        singletonServices.logger,
+        singletonServices.schema,
+        inputSchemaName,
+        actualData
+      )
+      // Coerce (top level) query string parameters or date objects if specified by the schema
+      if (coerceDataFromSchema) {
+        coerceTopLevelDataFromSchema(inputSchemaName, actualData)
+      }
+    }
+
+    const rpcLessWire = { ...wireWithInitialSession, rpc: undefined }
+
+    await runPermissions(wireType, wireId, {
+      wireInheritedPermissions: mergedInheritedPermissions,
+      wirePermissions: wirePermissions,
+      funcInheritedPermissions: funcMeta.permissions,
+      funcPermissions: funcConfig.permissions,
+      services: singletonServices,
+      wire: rpcLessWire as any,
+      data: actualData,
+    })
+
+    const wireServices = await createWireServices?.(
+      singletonServices,
+      wireWithInitialSession
+    )
+    try {
+      const services = { ...singletonServices, ...wireServices }
+      const rpc = rpcService.getContextRPCService(
+        services,
+        wireWithInitialSession
+      )
+      return await funcConfig.func(services, actualData, {
+        ...wireWithInitialSession,
+        rpc,
+      })
+    } finally {
+      if (wireServices) {
+        await closeWireServices(singletonServices.logger, wireServices)
+      }
+    }
+  }
+
+  const allMiddleware = combineMiddleware(wireType, wireId, {
+    wireInheritedMiddleware: inheritedMiddleware,
+    wireMiddleware,
+    funcInheritedMiddleware: funcMeta.middleware,
+    funcMiddleware: funcConfig.middleware,
+  })
+
+  if (allMiddleware.length > 0) {
+    return (await runMiddleware<CorePikkuMiddleware>(
+      singletonServices,
+      wire,
+      allMiddleware,
+      executeFunction
+    )) as Out
+  }
+
+  return (await executeFunction()) as Out
+}