@pikku/core 0.9.4 → 0.9.6

package/dist/wirings/scheduler/scheduler-runner.js

@@ -1,9 +1,10 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { closeSessionServices } from '../../utils.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
@@ -63,15 +64,20 @@ export async function runScheduledTask({ name, session, singletonServices, creat
                 }
                 return singletonServices;
             };
-            result = await runPikkuFunc(meta.pikkuFuncName, {
+            result = await runPikkuFunc(PikkuWiringTypes.scheduler, meta.name, meta.pikkuFuncName, {
                 getAllServices,
                 session,
                 data: undefined,
                 tags: task.tags,
             });
         };
-        // Get middleware for tags and run middleware
-        await runMiddleware(singletonServices, { scheduledTask }, addMiddlewareForTags(task.middleware, task.tags), runMain);
+        const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName);
+        await runMiddleware(singletonServices, { scheduledTask }, combineMiddleware(PikkuWiringTypes.scheduler, meta.name, {
+            wiringMiddleware: task.middleware,
+            wiringTags: task.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.tags,
+        }), runMain);
         return result;
     }
     catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",

package/src/factory-functions.test.ts

@@ -0,0 +1,37 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { pikkuPermission, pikkuMiddleware } from './index.js'
+
+test('pikkuPermission factory function', async () => {
+  const permission = pikkuPermission(async ({ logger }, data, session) => {
+    return true
+  })
+
+  assert.strictEqual(typeof permission, 'function')
+  assert.strictEqual(permission.length, 3) // services, data, session
+})
+
+test('pikkuMiddleware factory function', async () => {
+  const middleware = pikkuMiddleware(async ({ logger }, interactions, next) => {
+    await next()
+  })
+
+  assert.strictEqual(typeof middleware, 'function')
+  assert.strictEqual(middleware.length, 3) // services, interactions, next
+})
+
+test('pikkuPermission returns the same function', async () => {
+  const originalFn = async ({ logger }, data, session) => true
+  const wrappedFn = pikkuPermission(originalFn)
+
+  assert.strictEqual(wrappedFn, originalFn)
+})
+
+test('pikkuMiddleware returns the same function', async () => {
+  const originalFn = async ({ logger }, interactions, next) => {
+    await next()
+  }
+  const wrappedFn = pikkuMiddleware(originalFn)
+
+  assert.strictEqual(wrappedFn, originalFn)
+})

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

@@ -0,0 +1,499 @@
+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,
+  PikkuWiringTypes,
+} 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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+        tags: ['wiringTag'],
+      }),
+      {
+        message: 'Permission denied',
+      }
+    )
+  })
+
+  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(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+        permissions: wiringPermissions,
+      }),
+      {
+        message: 'Permission denied',
+      }
+    )
+  })
+
+  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(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+      }),
+      {
+        message: 'Permission denied',
+      }
+    )
+  })
+
+  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(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        getAllServices: () => mockServices,
+        data: {},
+      }),
+      {
+        message: 'Permission denied',
+      }
+    )
+  })
+
+  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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      '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(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      'testFunc',
+      {
+        getAllServices: asyncGetServices,
+        data: {},
+      }
+    )
+
+    assert.equal(result, 'success')
+    assert.equal(servicesProvided, mockServices)
+  })
+})

package/src/function/function-runner.ts

@@ -1,12 +1,13 @@
 import { ForbiddenError } from '../errors/errors.js'
-import { runMiddleware } from '../middleware-runner.js'
-import { verifyPermissions, getPermissionsForTags } 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 {
   CoreServices,
   CoreUserSession,
   CorePikkuMiddleware,
+  PikkuWiringTypes,
 } from '../types/core.types.js'
 import {
   CorePermissionGroup,
@@ -42,13 +43,15 @@ export const runPikkuFuncDirectly = async <In, Out>(
 }
 
 export const runPikkuFunc = async <In = any, Out = any>(
+  wireType: PikkuWiringTypes,
+  wireId: string,
   funcName: string,
   {
     getAllServices,
     data,
     session,
-    permissions: transportPermissions,
-    middleware: transportMiddleware,
+    permissions: wiringPermissions,
+    middleware: wiringMiddleware,
     coerceDataFromSchema,
     tags = [],
   }: {
@@ -93,46 +96,26 @@ export const runPikkuFunc = async <In = any, Out = any>(
     }
   }
 
-  let permissioned = true
-
-  // Check tagged permissions first - ALL must pass
-  const taggedPermissions = getPermissionsForTags([
-    ...tags,
-    ...(funcConfig.tags || []),
-  ])
-  if (taggedPermissions.length > 0) {
-    const taggedResults = await Promise.all(
-      taggedPermissions.map((permission) =>
-        permission(allServices, data, session)
-      )
-    )
-    permissioned = taggedResults.every((result) => result)
-  }
-
-  // Only check function permissions if tagged permissions passed
-  if (permissioned && 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(wireType, wireId, {
+    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(wireType, wireId, {
+    wiringTags: tags,
+    wiringMiddleware,
+    funcMiddleware: funcConfig.middleware,
+    funcTags: funcConfig.tags,
+  })
 
-  if (transportMiddleware || funcConfig.middleware) {
+  if (allMiddleware.length > 0) {
     return (await runMiddleware<CorePikkuMiddleware>(
       allServices,
       {
@@ -140,7 +123,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

@@ -74,6 +74,19 @@ export type CorePikkuPermission<
   Session extends CoreUserSession = CoreUserSession,
 > = (services: Services, data: In, session?: Session) => Promise<boolean>
 
+/**
+ * Factory function for creating permissions with tree-shaking support
+ */
+export const pikkuPermission = <
+  In = any,
+  Services extends CoreSingletonServices = CoreServices,
+  Session extends CoreUserSession = CoreUserSession,
+>(
+  permission: CorePikkuPermission<In, Services, Session>
+): CorePikkuPermission<In, Services, Session> => {
+  return permission
+}
+
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> =
   | Record<string, PikkuPermission | PikkuPermission[]>
   | undefined