@pikku/core 0.11.0 → 0.11.2

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) {
@@ -85,9 +82,10 @@ export const runMiddleware = async <Middleware extends CorePikkuMiddleware>(
  */
 export const addMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   tag: string,
-  middleware: CorePikkuMiddlewareGroup
+  middleware: CorePikkuMiddlewareGroup,
+  packageName: string | null = null
 ): CorePikkuMiddlewareGroup => {
-  const tagGroups = pikkuState('middleware', 'tagGroup')
+  const tagGroups = pikkuState(packageName, 'middleware', 'tagGroup')
   tagGroups[tag] = middleware
   return middleware
 }
@@ -103,10 +101,8 @@ export const addMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
  *
  * @internal
  */
-export const getMiddlewareByName = (
-  name: string
-): CorePikkuMiddleware | undefined => {
-  const middlewareStore = pikkuState('misc', 'middleware')
+const getMiddlewareByName = (name: string): CorePikkuMiddleware | undefined => {
+  const middlewareStore = pikkuState(null, 'misc', 'middleware')
   const middleware = middlewareStore[name]
   return middleware?.[0]
 }
@@ -115,14 +111,14 @@ const middlewareCache: Record<
   PikkuWiringTypes,
   Record<string, readonly CorePikkuMiddleware[]>
 > = {
-  [PikkuWiringTypes.http]: {},
-  [PikkuWiringTypes.rpc]: {},
-  [PikkuWiringTypes.channel]: {},
-  [PikkuWiringTypes.queue]: {},
-  [PikkuWiringTypes.scheduler]: {},
-  [PikkuWiringTypes.mcp]: {},
-  [PikkuWiringTypes.cli]: {},
-  [PikkuWiringTypes.workflow]: {},
+  http: {},
+  rpc: {},
+  channel: {},
+  queue: {},
+  scheduler: {},
+  mcp: {},
+  cli: {},
+  workflow: {},
 }
 
 /**
@@ -155,11 +151,13 @@ export const combineMiddleware = (
     wireMiddleware,
     funcInheritedMiddleware,
     funcMiddleware,
+    packageName = null,
   }: {
     wireInheritedMiddleware?: MiddlewareMetadata[]
     wireMiddleware?: CorePikkuMiddleware[]
     funcInheritedMiddleware?: MiddlewareMetadata[]
     funcMiddleware?: CorePikkuMiddleware[]
+    packageName?: string | null
   } = {}
 ): readonly CorePikkuMiddleware[] => {
   if (middlewareCache[wireType][uid]) {
@@ -173,14 +171,18 @@ export const combineMiddleware = (
     for (const meta of wireInheritedMiddleware) {
       if (meta.type === 'http') {
         // Look up HTTP middleware group from pikkuState
-        const group = pikkuState('middleware', 'httpGroup')[meta.route]
+        const group = pikkuState(packageName, 'middleware', 'httpGroup')[
+          meta.route
+        ]
         if (group) {
           // At runtime, all factories should be resolved to middleware
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       } else if (meta.type === 'tag') {
         // Look up tag middleware group from pikkuState
-        const group = pikkuState('middleware', 'tagGroup')[meta.tag]
+        const group = pikkuState(packageName, 'middleware', 'tagGroup')[
+          meta.tag
+        ]
         if (group) {
           // At runtime, all factories should be resolved to middleware
           resolved.push(...(group as CorePikkuMiddleware[]))
@@ -205,7 +207,9 @@ export const combineMiddleware = (
     for (const meta of funcInheritedMiddleware) {
       if (meta.type === 'tag') {
         // Look up tag middleware group from pikkuState
-        const group = pikkuState('middleware', 'tagGroup')[meta.tag]
+        const group = pikkuState(packageName, 'middleware', 'tagGroup')[
+          meta.tag
+        ]
         if (group) {
           // At runtime, all factories should be resolved to middleware
           resolved.push(...(group as CorePikkuMiddleware[]))