@pikku/core 0.9.3 → 0.9.5

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

@@ -0,0 +1,450 @@
+import { describe, test, beforeEach } from 'node:test'
+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 } from '../types/core.types.js'
+import { CorePermissionGroup } from './functions.types.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+// Helper function to add function with metadata for tests
+const addTestFunction = (funcName: string, funcConfig: any) => {
+  addFunction(funcName, funcConfig)
+  pikkuState('function', 'meta')[funcName] = {
+    pikkuFuncName: funcName,
+    inputSchemaName: null,
+    outputSchemaName: null,
+  }
+}
+
+const mockServices: CoreServices = {
+  logger: {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  },
+} as any
+
+describe('runPikkuFunc - Integration Tests', () => {
+  test('should execute middleware in correct order: wiringTags → wiringMiddleware → funcMiddleware → funcTags', async () => {
+    const executionOrder: string[] = []
+    const createMiddleware = (name: string): CorePikkuMiddleware => {
+      return async (services, interaction, next) => {
+        executionOrder.push(name)
+        await next()
+      }
+    }
+
+    addMiddleware('wiringTag', [createMiddleware('wiringTag')])
+    addMiddleware('funcTag', [createMiddleware('funcTag')])
+
+    // Register function with middleware and tags
+    addTestFunction('testFunc', {
+      func: async () => {
+        executionOrder.push('main')
+        return 'success'
+      },
+      middleware: [createMiddleware('funcMiddleware')],
+      tags: ['funcTag'],
+    })
+
+    const result = await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+      middleware: [createMiddleware('wiringMiddleware')],
+      tags: ['wiringTag'],
+    })
+
+    assert.equal(result, 'success')
+    // Order: wiringTags, wiringMiddleware, funcMiddleware, funcTags
+    assert.deepEqual(executionOrder, [
+      'wiringTag',
+      'wiringMiddleware',
+      'funcMiddleware',
+      'funcTag',
+      'main',
+    ])
+  })
+
+  test('should execute permissions in correct order: wiringTags → wiringPermissions → funcTags → funcPermissions', async () => {
+    const executionOrder: string[] = []
+
+    // Setup tagged permissions
+    const wiringTagPermission = async () => {
+      executionOrder.push('wiringTag')
+      return true
+    }
+    const funcTagPermission = async () => {
+      executionOrder.push('funcTag')
+      return true
+    }
+
+    addPermission('wiringTag', [wiringTagPermission])
+    addPermission('funcTag', [funcTagPermission])
+
+    // Setup direct permissions
+    const wiringPermissions: CorePermissionGroup = {
+      permissions: [
+        async () => {
+          executionOrder.push('wiringPermission')
+          return true
+        },
+      ],
+    }
+    const funcPermissions: CorePermissionGroup = {
+      permissions: [
+        async () => {
+          executionOrder.push('funcPermission')
+          return true
+        },
+      ],
+    }
+
+    // Register function with permissions and tags
+    addTestFunction('testFunc', {
+      func: async () => {
+        executionOrder.push('main')
+        return 'success'
+      },
+      permissions: funcPermissions,
+      tags: ['funcTag'],
+    })
+
+    const result = await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+      permissions: wiringPermissions,
+      tags: ['wiringTag'],
+    })
+
+    assert.equal(result, 'success')
+    // Order: wiringTags → wiringPermissions → funcTags → funcPermissions
+    assert.deepEqual(executionOrder, [
+      'wiringTag',
+      'wiringPermission',
+      'funcTag',
+      'funcPermission',
+      'main',
+    ])
+  })
+
+  test('should throw specific error for wiring tag permission failures', async () => {
+    const failingWiringTagPermission = async () => false
+
+    addPermission('wiringTag', [failingWiringTagPermission])
+
+    addTestFunction('testFunc', {
+      func: async () => 'success',
+    })
+
+    await assert.rejects(
+      runPikkuFunc('testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+        tags: ['wiringTag'],
+      }),
+      {
+        message: 'Permission denied - wiring tag permissions',
+      }
+    )
+  })
+
+  test('should throw specific error for wiring permission failures', async () => {
+    const wiringPermissions: CorePermissionGroup = {
+      permissions: [async () => false],
+    }
+
+    addTestFunction('testFunc', {
+      func: async () => 'success',
+    })
+
+    await assert.rejects(
+      runPikkuFunc('testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+        permissions: wiringPermissions,
+      }),
+      {
+        message: 'Permission denied - wiring permissions',
+      }
+    )
+  })
+
+  test('should throw specific error for function tag permission failures', async () => {
+    const failingFuncTagPermission = async () => false
+
+    addPermission('funcTag', [failingFuncTagPermission])
+
+    addTestFunction('testFunc', {
+      func: async () => 'success',
+      tags: ['funcTag'],
+    })
+
+    await assert.rejects(
+      runPikkuFunc('testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+      }),
+      {
+        message: 'Permission denied - function tag permissions',
+      }
+    )
+  })
+
+  test('should throw specific error for function permission failures', async () => {
+    const funcPermissions: CorePermissionGroup = {
+      permissions: [async () => false],
+    }
+
+    addTestFunction('testFunc', {
+      func: async () => 'success',
+      permissions: funcPermissions,
+    })
+
+    await assert.rejects(
+      runPikkuFunc('testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+      }),
+      {
+        message: 'Permission denied - function permissions',
+      }
+    )
+  })
+
+  test('should deduplicate middleware when same middleware appears in tags and direct', async () => {
+    let executionCount = 0
+
+    const duplicatedMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionCount++
+      await next()
+    }
+
+    // Add same middleware to tag and directly
+    addMiddleware('testTag', [duplicatedMiddleware])
+
+    addTestFunction('testFunc', {
+      func: async () => 'success',
+      middleware: [duplicatedMiddleware], // Same middleware directly
+      tags: ['testTag'], // Same middleware via tag
+    })
+
+    await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+    })
+
+    // Should only execute once due to deduplication
+    assert.equal(executionCount, 1)
+  })
+
+  test('should handle mixed permission types correctly', async () => {
+    const executionOrder: string[] = []
+
+    // Mix of array and object permissions
+    const arrayPermission = [
+      async () => {
+        executionOrder.push('arrayPermission1')
+        return false
+      },
+      async () => {
+        executionOrder.push('arrayPermission2')
+        return true
+      },
+    ]
+
+    const objectPermission: CorePermissionGroup = {
+      permissions: [
+        async () => {
+          executionOrder.push('objectPermission')
+          return true
+        },
+      ],
+    }
+
+    addPermission('mixedTag', arrayPermission)
+
+    addTestFunction('testFunc', {
+      func: async () => {
+        executionOrder.push('main')
+        return 'success'
+      },
+      permissions: objectPermission,
+      tags: ['mixedTag'],
+    })
+
+    const result = await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+    })
+
+    assert.equal(result, 'success')
+    // Should execute tag permissions first, then function permissions
+    assert.deepEqual(executionOrder, [
+      'arrayPermission1',
+      'arrayPermission2',
+      'objectPermission',
+      'main',
+    ])
+  })
+
+  test('should work without any middleware or permissions', async () => {
+    addTestFunction('simpleFunc', {
+      func: async () => 'simple success',
+    })
+
+    const result = await runPikkuFunc('simpleFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+    })
+
+    assert.equal(result, 'simple success')
+  })
+
+  test('should work with only wiring-level middleware and permissions', async () => {
+    const executionOrder: string[] = []
+
+    const wiringMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('wiringMiddleware')
+      await next()
+    }
+
+    const wiringPermissions: CorePermissionGroup = {
+      permissions: [
+        async () => {
+          executionOrder.push('wiringPermission')
+          return true
+        },
+      ],
+    }
+
+    addTestFunction('testFunc', {
+      func: async () => {
+        executionOrder.push('main')
+        return 'success'
+      },
+    })
+
+    const result = await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+      middleware: [wiringMiddleware],
+      permissions: wiringPermissions,
+    })
+
+    assert.equal(result, 'success')
+    assert.deepEqual(executionOrder, [
+      'wiringPermission',
+      'wiringMiddleware',
+      'main',
+    ])
+  })
+
+  test('should work with only function-level middleware and permissions', async () => {
+    const executionOrder: string[] = []
+
+    const funcMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('funcMiddleware')
+      await next()
+    }
+
+    const funcPermissions: CorePermissionGroup = {
+      permissions: [
+        async () => {
+          executionOrder.push('funcPermission')
+          return true
+        },
+      ],
+    }
+
+    addTestFunction('testFunc', {
+      func: async () => {
+        executionOrder.push('main')
+        return 'success'
+      },
+      middleware: [funcMiddleware],
+      permissions: funcPermissions,
+    })
+
+    const result = await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: {},
+    })
+
+    assert.equal(result, 'success')
+    assert.deepEqual(executionOrder, [
+      'funcPermission',
+      'funcMiddleware',
+      'main',
+    ])
+  })
+
+  test('should pass correct parameters to function', async () => {
+    let receivedServices: any
+    let receivedData: any
+    let receivedSession: any
+
+    const testData = { test: 'data' }
+    const testSession = { userId: 'test-user' }
+
+    addTestFunction('testFunc', {
+      func: async (services, data, session) => {
+        receivedServices = services
+        receivedData = data
+        receivedSession = session
+        return 'success'
+      },
+    })
+
+    await runPikkuFunc('testFunc', {
+      getAllServices: () => mockServices,
+      data: testData,
+      session: testSession,
+    })
+
+    assert.equal(receivedServices, mockServices)
+    assert.equal(receivedData, testData)
+    assert.equal(receivedSession, testSession)
+  })
+
+  test('should handle async getAllServices function', async () => {
+    let servicesProvided: any
+
+    addTestFunction('testFunc', {
+      func: async (services) => {
+        servicesProvided = services
+        return 'success'
+      },
+    })
+
+    const asyncGetServices = async () => {
+      // Simulate async service creation
+      await new Promise((resolve) => setTimeout(resolve, 1))
+      return mockServices
+    }
+
+    const result = await runPikkuFunc('testFunc', {
+      getAllServices: asyncGetServices,
+      data: {},
+    })
+
+    assert.equal(result, 'success')
+    assert.equal(servicesProvided, mockServices)
+  })
+})

package/src/function/function-runner.ts

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '../errors/errors.js'
-import { runMiddleware } from '../middleware-runner.js'
-import { verifyPermissions } from '../permissions.js'
+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 {
@@ -47,9 +47,10 @@ export const runPikkuFunc = async <In = any, Out = any>(
     getAllServices,
     data,
     session,
-    permissions: transportPermissions,
-    middleware: transportMiddleware,
+    permissions: wiringPermissions,
+    middleware: wiringMiddleware,
     coerceDataFromSchema,
+    tags = [],
   }: {
     getAllServices: () => Promise<CoreServices> | CoreServices
     data: In
@@ -57,6 +58,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
     permissions?: CorePermissionGroup
     middleware?: CorePikkuMiddleware[]
     coerceDataFromSchema?: boolean
+    tags?: string[]
   }
 ): Promise<Out> => {
   const funcConfig = pikkuState('function', 'functions').get(funcName)
@@ -91,29 +93,26 @@ export const runPikkuFunc = async <In = any, Out = any>(
     }
   }
 
-  let permissioned = true
-  if (funcConfig.permissions) {
-    permissioned = await verifyPermissions(
-      funcConfig.permissions,
-      allServices,
-      data,
-      session
-    )
-  }
-  if (!permissioned && transportPermissions) {
-    permissioned = await verifyPermissions(
-      transportPermissions,
-      allServices,
-      data,
-      session
-    )
-  }
+  // Run permission checks in the specified order
+  await runPermissions({
+    wiringTags: tags,
+    wiringPermissions,
+    funcTags: funcConfig.tags,
+    funcPermissions: funcConfig.permissions,
+    allServices,
+    data,
+    session,
+  })
 
-  if (permissioned === false) {
-    throw new ForbiddenError('Permission denied')
-  }
+  // Combine all middleware: wiring tags → wiring middleware → func middleware → func tags
+  const allMiddleware = combineMiddleware({
+    wiringTags: tags,
+    wiringMiddleware,
+    funcMiddleware: funcConfig.middleware,
+    funcTags: funcConfig.tags,
+  })
 
-  if (transportMiddleware || funcConfig.middleware) {
+  if (allMiddleware.length > 0) {
     return (await runMiddleware<CorePikkuMiddleware>(
       allServices,
       {
@@ -121,7 +120,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
         mcp: allServices.mcp,
         rpc: allServices.rpc,
       },
-      [...(transportMiddleware || []), ...(funcConfig.middleware || [])],
+      allMiddleware,
       async () => await funcConfig.func(allServices, data, session!)
     )) as Out
   }

package/src/function/functions.types.ts

@@ -87,12 +87,14 @@ export type CorePikkuFunctionConfig<
     any,
     any
   > = CorePikkuPermission<any>,
+  PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>,
 > = {
   name?: string
   expose?: boolean
   func: PikkuFunction
   auth?: boolean
   permissions?: CorePermissionGroup<PikkuPermission>
-  middleware?: CorePikkuMiddleware[]
+  middleware?: PikkuMiddleware[]
+  tags?: string[]
   docs?: PikkuDocs
 }

package/src/index.ts

@@ -21,7 +21,16 @@ export * from './middleware/index.js'
 export * from './time-utils.js'
 export * from './utils.js'
 export { pikkuState } from './pikku-state.js'
-export { runMiddleware } from './middleware-runner.js'
+export {
+  runMiddleware,
+  addMiddleware,
+  combineMiddleware,
+} from './middleware-runner.js'
+export {
+  addPermission,
+  getPermissionsForTags,
+  runPermissions,
+} from './permissions.js'
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js'
 export { wireChannel } from './wirings/channel/channel-runner.js'
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js'