@pikku/core 0.9.5 → 0.9.7

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

@@ -3,7 +3,11 @@ 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 {
+  CoreServices,
+  CorePikkuMiddleware,
+  PikkuWiringTypes,
+} from '../types/core.types.js'
 import { CorePermissionGroup } from './functions.types.js'
 
 beforeEach(() => {
@@ -52,12 +56,17 @@ describe('runPikkuFunc - Integration Tests', () => {
       tags: ['funcTag'],
     })
 
-    const result = await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-      middleware: [createMiddleware('wiringMiddleware')],
-      tags: ['wiringTag'],
-    })
+    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
@@ -114,12 +123,17 @@ describe('runPikkuFunc - Integration Tests', () => {
       tags: ['funcTag'],
     })
 
-    const result = await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-      permissions: wiringPermissions,
-      tags: ['wiringTag'],
-    })
+    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
@@ -142,13 +156,13 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc('testFunc', {
+      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
         getAllServices: () => mockServices,
         data: {},
         tags: ['wiringTag'],
       }),
       {
-        message: 'Permission denied - wiring tag permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -163,13 +177,13 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc('testFunc', {
+      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
         getAllServices: () => mockServices,
         data: {},
         permissions: wiringPermissions,
       }),
       {
-        message: 'Permission denied - wiring permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -185,12 +199,12 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc('testFunc', {
+      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
         getAllServices: () => mockServices,
         data: {},
       }),
       {
-        message: 'Permission denied - function tag permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -206,12 +220,12 @@ describe('runPikkuFunc - Integration Tests', () => {
     })
 
     await assert.rejects(
-      runPikkuFunc('testFunc', {
+      runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
         getAllServices: () => mockServices,
         data: {},
       }),
       {
-        message: 'Permission denied - function permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -237,10 +251,15 @@ describe('runPikkuFunc - Integration Tests', () => {
       tags: ['testTag'], // Same middleware via tag
     })
 
-    await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-    })
+    await runPikkuFunc(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      'testFunc',
+      {
+        getAllServices: () => mockServices,
+        data: {},
+      }
+    )
 
     // Should only execute once due to deduplication
     assert.equal(executionCount, 1)
@@ -281,10 +300,15 @@ describe('runPikkuFunc - Integration Tests', () => {
       tags: ['mixedTag'],
     })
 
-    const result = await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-    })
+    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
@@ -301,10 +325,15 @@ describe('runPikkuFunc - Integration Tests', () => {
       func: async () => 'simple success',
     })
 
-    const result = await runPikkuFunc('simpleFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-    })
+    const result = await runPikkuFunc(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      'simpleFunc',
+      {
+        getAllServices: () => mockServices,
+        data: {},
+      }
+    )
 
     assert.equal(result, 'simple success')
   })
@@ -337,12 +366,17 @@ describe('runPikkuFunc - Integration Tests', () => {
       },
     })
 
-    const result = await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-      middleware: [wiringMiddleware],
-      permissions: wiringPermissions,
-    })
+    const result = await runPikkuFunc(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      'testFunc',
+      {
+        getAllServices: () => mockServices,
+        data: {},
+        middleware: [wiringMiddleware],
+        permissions: wiringPermissions,
+      }
+    )
 
     assert.equal(result, 'success')
     assert.deepEqual(executionOrder, [
@@ -382,10 +416,15 @@ describe('runPikkuFunc - Integration Tests', () => {
       permissions: funcPermissions,
     })
 
-    const result = await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: {},
-    })
+    const result = await runPikkuFunc(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      'testFunc',
+      {
+        getAllServices: () => mockServices,
+        data: {},
+      }
+    )
 
     assert.equal(result, 'success')
     assert.deepEqual(executionOrder, [
@@ -412,11 +451,16 @@ describe('runPikkuFunc - Integration Tests', () => {
       },
     })
 
-    await runPikkuFunc('testFunc', {
-      getAllServices: () => mockServices,
-      data: testData,
-      session: testSession,
-    })
+    await runPikkuFunc(
+      PikkuWiringTypes.rpc,
+      Math.random().toString(),
+      'testFunc',
+      {
+        getAllServices: () => mockServices,
+        data: testData,
+        session: testSession,
+      }
+    )
 
     assert.equal(receivedServices, mockServices)
     assert.equal(receivedData, testData)
@@ -439,10 +483,15 @@ describe('runPikkuFunc - Integration Tests', () => {
       return mockServices
     }
 
-    const result = await runPikkuFunc('testFunc', {
-      getAllServices: asyncGetServices,
-      data: {},
-    })
+    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

@@ -7,6 +7,7 @@ import {
   CoreServices,
   CoreUserSession,
   CorePikkuMiddleware,
+  PikkuWiringTypes,
 } from '../types/core.types.js'
 import {
   CorePermissionGroup,
@@ -42,6 +43,8 @@ export const runPikkuFuncDirectly = async <In, Out>(
 }
 
 export const runPikkuFunc = async <In = any, Out = any>(
+  wireType: PikkuWiringTypes,
+  wireId: string,
   funcName: string,
   {
     getAllServices,
@@ -94,7 +97,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
   }
 
   // Run permission checks in the specified order
-  await runPermissions({
+  await runPermissions(wireType, wireId, {
     wiringTags: tags,
     wiringPermissions,
     funcTags: funcConfig.tags,
@@ -105,7 +108,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
   })
 
   // Combine all middleware: wiring tags → wiring middleware → func middleware → func tags
-  const allMiddleware = combineMiddleware({
+  const allMiddleware = combineMiddleware(wireType, wireId, {
     wiringTags: tags,
     wiringMiddleware,
     funcMiddleware: funcConfig.middleware,

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

package/src/index.ts

@@ -18,19 +18,11 @@ export * from './wirings/queue/index.js'
 export * from './wirings/mcp/index.js'
 export * from './errors/index.js'
 export * from './middleware/index.js'
-export * from './time-utils.js'
 export * from './utils.js'
+export * from './time-utils.js'
 export { pikkuState } from './pikku-state.js'
-export {
-  runMiddleware,
-  addMiddleware,
-  combineMiddleware,
-} from './middleware-runner.js'
-export {
-  addPermission,
-  getPermissionsForTags,
-  runPermissions,
-} from './permissions.js'
+export { addMiddleware, runMiddleware } from './middleware-runner.js'
+export { addPermission } 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'

package/src/middleware-runner.test.ts

@@ -3,11 +3,10 @@ import assert from 'node:assert'
 import {
   combineMiddleware,
   addMiddleware,
-  getMiddlewareForTags,
   runMiddleware,
 } from './middleware-runner.js'
 import { resetPikkuState } from './pikku-state.js'
-import { CorePikkuMiddleware } from './types/core.types.js'
+import { CorePikkuMiddleware, PikkuWiringTypes } from './types/core.types.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -15,17 +14,24 @@ beforeEach(() => {
 
 describe('combineMiddleware', () => {
   test('should return empty array when no parameters provided', () => {
-    const result = combineMiddleware()
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString()
+    )
     assert.deepEqual(result, [])
   })
 
   test('should return empty array when all parameters are undefined', () => {
-    const result = combineMiddleware({
-      wiringMiddleware: undefined,
-      wiringTags: undefined,
-      funcMiddleware: undefined,
-      funcTags: undefined,
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringMiddleware: undefined,
+        wiringTags: undefined,
+        funcMiddleware: undefined,
+        funcTags: undefined,
+      }
+    )
     assert.deepEqual(result, [])
   })
 
@@ -45,9 +51,13 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    const result = combineMiddleware({
-      wiringMiddleware: [mockMiddleware1, mockMiddleware2],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringMiddleware: [mockMiddleware1, mockMiddleware2],
+      }
+    )
 
     assert.equal(result.length, 2)
     assert.equal(result[0], mockMiddleware1)
@@ -70,9 +80,13 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    const result = combineMiddleware({
-      funcMiddleware: [mockMiddleware1, mockMiddleware2],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        funcMiddleware: [mockMiddleware1, mockMiddleware2],
+      }
+    )
 
     assert.equal(result.length, 2)
     assert.equal(result[0], mockMiddleware1)
@@ -114,12 +128,16 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    const result = combineMiddleware({
-      wiringMiddleware: [wiringMiddleware],
-      wiringTags: ['wiringTag'],
-      funcMiddleware: [funcMiddleware],
-      funcTags: ['funcTag'],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringMiddleware: [wiringMiddleware],
+        wiringTags: ['wiringTag'],
+        funcMiddleware: [funcMiddleware],
+        funcTags: ['funcTag'],
+      }
+    )
 
     assert.equal(result.length, 4)
     // Order: wiringTags, wiringMiddleware, funcMiddleware, funcTags
@@ -140,9 +158,13 @@ describe('combineMiddleware', () => {
 
     addMiddleware('testTag', [taggedMiddleware])
 
-    const result = combineMiddleware({
-      wiringTags: ['testTag'],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringTags: ['testTag'],
+      }
+    )
 
     assert.equal(result.length, 1)
     assert.equal(result[0], taggedMiddleware)
@@ -159,9 +181,13 @@ describe('combineMiddleware', () => {
 
     addMiddleware('funcTestTag', [taggedMiddleware])
 
-    const result = combineMiddleware({
-      funcTags: ['funcTestTag'],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        funcTags: ['funcTestTag'],
+      }
+    )
 
     assert.equal(result.length, 1)
     assert.equal(result[0], taggedMiddleware)
@@ -186,9 +212,13 @@ describe('combineMiddleware', () => {
     addMiddleware('tag1', [middleware1])
     addMiddleware('tag2', [middleware2])
 
-    const result = combineMiddleware({
-      wiringTags: ['tag1', 'tag2'],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringTags: ['tag1', 'tag2'],
+      }
+    )
 
     assert.equal(result.length, 2)
     assert.equal(result[0], middleware1)
@@ -206,10 +236,14 @@ describe('combineMiddleware', () => {
 
     addMiddleware('existingTag', [middleware])
 
-    const result = combineMiddleware({
-      wiringTags: ['existingTag', 'nonExistentTag'],
-      funcTags: ['anotherNonExistentTag'],
-    })
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringTags: ['existingTag', 'nonExistentTag'],
+        funcTags: ['anotherNonExistentTag'],
+      }
+    )
 
     assert.equal(result.length, 1)
     assert.equal(result[0], middleware)
@@ -238,18 +272,12 @@ describe('runMiddleware', () => {
       await next()
     }
 
-    // Pass same middleware multiple times
-    const duplicatedMiddleware = [
-      middleware1,
-      middleware2,
-      middleware1,
-      middleware2,
-    ]
-
     await runMiddleware(
       {} as any,
       {} as any,
-      duplicatedMiddleware,
+      combineMiddleware(PikkuWiringTypes.rpc, Math.random().toString(), {
+        wiringMiddleware: [middleware1, middleware2, middleware1, middleware2],
+      }),
       async () => {
         executionOrder.push('main')
       }

package/src/middleware-runner.ts

@@ -3,8 +3,10 @@ import {
   CoreSingletonServices,
   PikkuInteraction,
   CorePikkuMiddleware,
+  PikkuWiringTypes,
 } from './types/core.types.js'
 import { pikkuState } from './pikku-state.js'
+import { freezeDedupe } from './utils.js'
 
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
@@ -28,15 +30,14 @@ export const runMiddleware = async <Middleware extends CorePikkuMiddleware>(
     userSession?: UserSessionService<any>
   },
   interaction: PikkuInteraction,
-  middlewares: Middleware[],
+  middlewares: readonly Middleware[],
   main?: () => Promise<unknown>
 ): Promise<unknown> => {
   // Deduplicate middleware using Set to avoid running the same middleware multiple times
-  const uniqueMiddleware = Array.from(new Set(middlewares))
   let result: any
   const dispatch = async (index: number): Promise<any> => {
-    if (uniqueMiddleware && index < uniqueMiddleware.length) {
-      return await uniqueMiddleware[index]!(services as any, interaction, () =>
+    if (middlewares && index < middlewares.length) {
+      return await middlewares[index]!(services as any, interaction, () =>
         dispatch(index + 1)
       )
     } else if (main) {
@@ -123,6 +124,18 @@ export const getMiddlewareForTags = (
   return applicableMiddleware
 }
 
+const middlewareCache: Record<
+  PikkuWiringTypes,
+  Record<string, readonly CorePikkuMiddleware[]>
+> = {
+  [PikkuWiringTypes.http]: {},
+  [PikkuWiringTypes.rpc]: {},
+  [PikkuWiringTypes.channel]: {},
+  [PikkuWiringTypes.queue]: {},
+  [PikkuWiringTypes.scheduler]: {},
+  [PikkuWiringTypes.mcp]: {},
+}
+
 /**
  * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
@@ -146,17 +159,27 @@ export const getMiddlewareForTags = (
  * })
  * ```
  */
-export const combineMiddleware = ({
-  wiringMiddleware,
-  wiringTags,
-  funcMiddleware,
-  funcTags,
-}: {
-  wiringMiddleware?: CorePikkuMiddleware[]
-  wiringTags?: string[]
-  funcMiddleware?: CorePikkuMiddleware[]
-  funcTags?: string[]
-} = {}): CorePikkuMiddleware[] => {
+export const combineMiddleware = (
+  wireType: PikkuWiringTypes,
+  uid: string,
+  {
+    httpMiddleware,
+    wiringMiddleware,
+    wiringTags,
+    funcMiddleware,
+    funcTags,
+  }: {
+    httpMiddleware?: CorePikkuMiddleware[]
+    wiringMiddleware?: CorePikkuMiddleware[]
+    wiringTags?: string[]
+    funcMiddleware?: CorePikkuMiddleware[]
+    funcTags?: string[]
+  } = {}
+): readonly CorePikkuMiddleware[] => {
+  if (middlewareCache[wireType][uid]) {
+    return middlewareCache[wireType][uid]
+  }
+
   // Run middleware in specific order:
   // 1) wiringTags middleware
   // 2) wiringMiddleware
@@ -165,10 +188,13 @@ export const combineMiddleware = ({
   const wiringTaggedMiddleware = getMiddlewareForTags(wiringTags)
   const funcTaggedMiddleware = getMiddlewareForTags(funcTags)
 
-  return [
+  middlewareCache[wireType][uid] = freezeDedupe([
+    ...(httpMiddleware || []),
     ...wiringTaggedMiddleware,
     ...(wiringMiddleware || []),
     ...(funcMiddleware || []),
     ...funcTaggedMiddleware,
-  ]
+  ]) as readonly CorePikkuMiddleware[]
+
+  return middlewareCache[wireType][uid]
 }