@pikku/core 0.10.2 → 0.11.1

package/src/middleware-runner.test.ts

@@ -6,7 +6,7 @@ import {
   runMiddleware,
 } from './middleware-runner.js'
 import { resetPikkuState } from './pikku-state.js'
-import { CorePikkuMiddleware, PikkuWiringTypes } from './types/core.types.js'
+import { CorePikkuMiddleware } from './types/core.types.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -14,50 +14,39 @@ beforeEach(() => {
 
 describe('combineMiddleware', () => {
   test('should return empty array when no parameters provided', () => {
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString()
-    )
+    const result = combineMiddleware('http', Math.random().toString())
     assert.deepEqual(result, [])
   })
 
   test('should return empty array when all parameters are undefined', () => {
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        wiringMiddleware: undefined,
-        wiringTags: undefined,
-        funcMiddleware: undefined,
-        funcTags: undefined,
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wiringMiddleware: undefined,
+      wiringTags: undefined,
+      funcMiddleware: undefined,
+      funcTags: undefined,
+    })
     assert.deepEqual(result, [])
   })
 
   test('should combine wiring middleware only', () => {
     const mockMiddleware1: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
     const mockMiddleware2: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        wireMiddleware: [mockMiddleware1, mockMiddleware2],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireMiddleware: [mockMiddleware1, mockMiddleware2],
+    })
 
     assert.equal(result.length, 2)
     assert.equal(result[0], mockMiddleware1)
@@ -67,26 +56,22 @@ describe('combineMiddleware', () => {
   test('should combine function middleware only', () => {
     const mockMiddleware1: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
     const mockMiddleware2: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        funcMiddleware: [mockMiddleware1, mockMiddleware2],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      funcMiddleware: [mockMiddleware1, mockMiddleware2],
+    })
 
     assert.equal(result.length, 2)
     assert.equal(result[0], mockMiddleware1)
@@ -97,14 +82,14 @@ describe('combineMiddleware', () => {
     // Setup tagged middleware
     const wiringTagMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
     const funcTagMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
@@ -115,29 +100,25 @@ describe('combineMiddleware', () => {
 
     const wiringMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
     const funcMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
     }
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        wireInheritedMiddleware: [{ type: 'tag', tag: 'wiringTag' }],
-        wireMiddleware: [wiringMiddleware],
-        funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTag' }],
-        funcMiddleware: [funcMiddleware],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [{ type: 'tag', tag: 'wiringTag' }],
+      wireMiddleware: [wiringMiddleware],
+      funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTag' }],
+      funcMiddleware: [funcMiddleware],
+    })
 
     assert.equal(result.length, 4)
     // Order: wireInheritedMiddleware (tags), wireMiddleware, funcInheritedMiddleware (tags), funcMiddleware
@@ -150,7 +131,7 @@ describe('combineMiddleware', () => {
   test('should handle wiring tags only', () => {
     const taggedMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
@@ -158,13 +139,9 @@ describe('combineMiddleware', () => {
 
     addMiddleware('testTag', [taggedMiddleware])
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        wireInheritedMiddleware: [{ type: 'tag', tag: 'testTag' }],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [{ type: 'tag', tag: 'testTag' }],
+    })
 
     assert.equal(result.length, 1)
     assert.equal(result[0], taggedMiddleware)
@@ -173,7 +150,7 @@ describe('combineMiddleware', () => {
   test('should handle function tags only', () => {
     const taggedMiddleware: CorePikkuMiddleware = async (
       services,
-      interaction,
+      wire,
       next
     ) => {
       await next()
@@ -181,47 +158,31 @@ describe('combineMiddleware', () => {
 
     addMiddleware('funcTestTag', [taggedMiddleware])
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTestTag' }],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTestTag' }],
+    })
 
     assert.equal(result.length, 1)
     assert.equal(result[0], taggedMiddleware)
   })
 
   test('should handle multiple tags', () => {
-    const middleware1: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware1: CorePikkuMiddleware = async (services, wire, next) => {
       await next()
     }
-    const middleware2: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware2: CorePikkuMiddleware = async (services, wire, next) => {
       await next()
     }
 
     addMiddleware('tag1', [middleware1])
     addMiddleware('tag2', [middleware2])
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        wireInheritedMiddleware: [
-          { type: 'tag', tag: 'tag1' },
-          { type: 'tag', tag: 'tag2' },
-        ],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [
+        { type: 'tag', tag: 'tag1' },
+        { type: 'tag', tag: 'tag2' },
+      ],
+    })
 
     assert.equal(result.length, 2)
     assert.equal(result[0], middleware1)
@@ -229,29 +190,19 @@ describe('combineMiddleware', () => {
   })
 
   test('should ignore non-existent tags', () => {
-    const middleware: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware: CorePikkuMiddleware = async (services, wire, next) => {
       await next()
     }
 
     addMiddleware('existingTag', [middleware])
 
-    const result = combineMiddleware(
-      PikkuWiringTypes.http,
-      Math.random().toString(),
-      {
-        wireInheritedMiddleware: [
-          { type: 'tag', tag: 'existingTag' },
-          { type: 'tag', tag: 'nonExistentTag' },
-        ],
-        funcInheritedMiddleware: [
-          { type: 'tag', tag: 'anotherNonExistentTag' },
-        ],
-      }
-    )
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [
+        { type: 'tag', tag: 'existingTag' },
+        { type: 'tag', tag: 'nonExistentTag' },
+      ],
+      funcInheritedMiddleware: [{ type: 'tag', tag: 'anotherNonExistentTag' }],
+    })
 
     assert.equal(result.length, 1)
     assert.equal(result[0], middleware)
@@ -262,20 +213,12 @@ describe('runMiddleware', () => {
   test('should deduplicate middleware using Set', async () => {
     const executionOrder: string[] = []
 
-    const middleware1: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware1: CorePikkuMiddleware = async (services, wire, next) => {
       executionOrder.push('middleware1')
       await next()
     }
 
-    const middleware2: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware2: CorePikkuMiddleware = async (services, wire, next) => {
       executionOrder.push('middleware2')
       await next()
     }
@@ -283,7 +226,7 @@ describe('runMiddleware', () => {
     await runMiddleware(
       {} as any,
       {} as any,
-      combineMiddleware(PikkuWiringTypes.rpc, Math.random().toString(), {
+      combineMiddleware('rpc', Math.random().toString(), {
         wireMiddleware: [middleware1, middleware2, middleware1, middleware2],
       }),
       async () => {
@@ -298,21 +241,13 @@ describe('runMiddleware', () => {
   test('should execute middleware in correct order', async () => {
     const executionOrder: string[] = []
 
-    const middleware1: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware1: CorePikkuMiddleware = async (services, wire, next) => {
       executionOrder.push('start1')
       await next()
       executionOrder.push('end1')
     }
 
-    const middleware2: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware2: CorePikkuMiddleware = async (services, wire, next) => {
       executionOrder.push('start2')
       await next()
       executionOrder.push('end2')
@@ -349,11 +284,7 @@ describe('runMiddleware', () => {
   test('should work without main function', async () => {
     const executionOrder: string[] = []
 
-    const middleware: CorePikkuMiddleware = async (
-      services,
-      interaction,
-      next
-    ) => {
+    const middleware: CorePikkuMiddleware = async (services, wire, next) => {
       executionOrder.push('middleware')
       await next()
     }

package/src/middleware-runner.ts

@@ -1,7 +1,6 @@
-import { UserSessionService } from './services/user-session-service.js'
 import {
   CoreSingletonServices,
-  PikkuInteraction,
+  PikkuWire,
   CorePikkuMiddleware,
   CorePikkuMiddlewareGroup,
   PikkuWiringTypes,
@@ -14,7 +13,7 @@ import { freezeDedupe } from './utils.js'
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
  * @param services - An object containing services (e.g., singletonServices, userSession, etc.)
- * @param interaction - The interaction context, e.g., { http }.
+ * @param wire - The wire context, e.g., { http }.
  * @param middlewares - An array of middleware functions to run.
  * @param main - The main function to execute after all middleware have run.
  * @returns A promise resolving to the result of the main function.
@@ -28,10 +27,8 @@ import { freezeDedupe } from './utils.js'
  * );
  */
 export const runMiddleware = async <Middleware extends CorePikkuMiddleware>(
-  services: CoreSingletonServices & {
-    userSession?: UserSessionService<any>
-  },
-  interaction: PikkuInteraction,
+  services: CoreSingletonServices,
+  wire: PikkuWire,
   middlewares: readonly Middleware[],
   main?: () => Promise<unknown>
 ): Promise<unknown> => {
@@ -39,7 +36,7 @@ export const runMiddleware = async <Middleware extends CorePikkuMiddleware>(
   let result: any
   const dispatch = async (index: number): Promise<any> => {
     if (middlewares && index < middlewares.length) {
-      return await middlewares[index]!(services as any, interaction, () =>
+      return await middlewares[index]!(services as any, wire, () =>
         dispatch(index + 1)
       )
     } else if (main) {
@@ -115,13 +112,14 @@ const middlewareCache: Record<
   PikkuWiringTypes,
   Record<string, readonly CorePikkuMiddleware[]>
 > = {
-  [PikkuWiringTypes.http]: {},
-  [PikkuWiringTypes.rpc]: {},
-  [PikkuWiringTypes.channel]: {},
-  [PikkuWiringTypes.queue]: {},
-  [PikkuWiringTypes.scheduler]: {},
-  [PikkuWiringTypes.mcp]: {},
-  [PikkuWiringTypes.cli]: {},
+  http: {},
+  rpc: {},
+  channel: {},
+  queue: {},
+  scheduler: {},
+  mcp: {},
+  cli: {},
+  workflow: {},
 }
 
 /**

package/src/permissions.test.ts

@@ -6,11 +6,7 @@ import {
   runPermissions,
 } from './permissions.js'
 import { resetPikkuState } from './pikku-state.js'
-import {
-  CoreServices,
-  CoreUserSession,
-  PikkuWiringTypes,
-} from './types/core.types.js'
+import { CoreServices, CoreUserSession } from './types/core.types.js'
 import { CorePermissionGroup } from './function/functions.types.js'
 
 beforeEach(() => {
@@ -164,10 +160,10 @@ describe('getPermissionsForTags', () => {
 describe('runPermissions', () => {
   test('should pass when no permissions are defined', async () => {
     // Should not throw
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
-      allServices: mockServices,
+    await runPermissions('rpc', Math.random().toString(), {
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
   })
 
@@ -180,11 +176,11 @@ describe('runPermissions', () => {
 
     addPermission('wiringTag', [wiringTagPermission])
 
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'wiringTag' }],
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
 
     assert.deepEqual(executionOrder, ['wiringTag'])
@@ -223,14 +219,14 @@ describe('runPermissions', () => {
       ],
     }
 
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'wiringTag' }],
       wirePermissions,
       funcInheritedPermissions: [{ type: 'tag', tag: 'funcTag' }],
       funcPermissions,
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
 
     // Order: wireInheritedPermissions (wiringTag) → wirePermissions → funcInheritedPermissions (funcTag) → funcPermissions
@@ -249,11 +245,11 @@ describe('runPermissions', () => {
     addPermission('atLeastOneTestTag', [failingPermission, passingPermission])
 
     // Should not throw because at least one permission passes
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'atLeastOneTestTag' }],
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
   })
 
@@ -264,11 +260,11 @@ describe('runPermissions', () => {
     addPermission('allFailTestTag', [failingPermission1, failingPermission2])
 
     await assert.rejects(
-      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+      runPermissions('rpc', Math.random().toString(), {
         wireInheritedPermissions: [{ type: 'tag', tag: 'allFailTestTag' }],
-        allServices: mockServices,
+        services: mockServices,
+        wire: {},
         data: {},
-        session: mockSession,
       }),
       {
         message: 'Permission denied',
@@ -282,11 +278,11 @@ describe('runPermissions', () => {
     }
 
     await assert.rejects(
-      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+      runPermissions('rpc', Math.random().toString(), {
         wirePermissions,
-        allServices: mockServices,
+        services: mockServices,
+        wire: {},
         data: {},
-        session: mockSession,
       }),
       {
         message: 'Permission denied',
@@ -300,11 +296,11 @@ describe('runPermissions', () => {
     addPermission('funcTag', [failingPermission])
 
     await assert.rejects(
-      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+      runPermissions('rpc', Math.random().toString(), {
         funcInheritedPermissions: [{ type: 'tag', tag: 'funcTag' }],
-        allServices: mockServices,
+        services: mockServices,
+        wire: {},
         data: {},
-        session: mockSession,
       }),
       {
         message: 'Permission denied',
@@ -318,11 +314,11 @@ describe('runPermissions', () => {
     }
 
     await assert.rejects(
-      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+      runPermissions('rpc', Math.random().toString(), {
         funcPermissions,
-        allServices: mockServices,
+        services: mockServices,
+        wire: {},
         data: {},
-        session: mockSession,
       }),
       {
         message: 'Permission denied',
@@ -350,12 +346,12 @@ describe('runPermissions', () => {
     }
 
     // Should NOT throw because at least one permission (wirePermissions) passes
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'failingWiringTag' }],
       wirePermissions,
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
 
     // Both permissions should be evaluated
@@ -368,11 +364,11 @@ describe('runPermissions', () => {
     addPermission('arrayTestTag', arrayPermission)
 
     // Should not throw because verifyPermissions handles array properly
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'arrayTestTag' }],
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
   })
 
@@ -384,23 +380,23 @@ describe('runPermissions', () => {
     addPermission('objectTestTag', permissionGroup)
 
     // Should not throw because verifyPermissions handles objects properly
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'objectTestTag' }],
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: {},
-      session: mockSession,
     })
   })
 
   test('should pass correct parameters to permission functions', async () => {
     let receivedServices: any
+    let receivedWire: any
     let receivedData: any
-    let receivedSession: any
 
-    const testPermission = async (services: any, data: any, session: any) => {
+    const testPermission = async (services: any, data: any, wire: any) => {
       receivedServices = services
       receivedData = data
-      receivedSession = session
+      receivedWire = wire
       return true
     }
 
@@ -408,15 +404,15 @@ describe('runPermissions', () => {
 
     addPermission('paramTestTag', [testPermission])
 
-    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
+    await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'paramTestTag' }],
-      allServices: mockServices,
+      services: mockServices,
+      wire: {},
       data: testData,
-      session: mockSession,
     })
 
     assert.equal(receivedServices, mockServices)
     assert.equal(receivedData, testData)
-    assert.equal(receivedSession, mockSession)
+    assert.deepEqual(receivedWire, {})
   })
 })