@pikku/core 0.9.4 → 0.9.6

package/src/index.ts

@@ -18,15 +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,
-  addMiddlewareForTags,
-} from './middleware-runner.js'
-export { addPermission, getPermissionsForTags } 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

@@ -0,0 +1,357 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import {
+  combineMiddleware,
+  addMiddleware,
+  runMiddleware,
+} from './middleware-runner.js'
+import { resetPikkuState } from './pikku-state.js'
+import { CorePikkuMiddleware, PikkuWiringTypes } from './types/core.types.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('combineMiddleware', () => {
+  test('should return empty array when no parameters provided', () => {
+    const result = combineMiddleware(
+      PikkuWiringTypes.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,
+      }
+    )
+    assert.deepEqual(result, [])
+  })
+
+  test('should combine wiring middleware only', () => {
+    const mockMiddleware1: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+    const mockMiddleware2: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringMiddleware: [mockMiddleware1, mockMiddleware2],
+      }
+    )
+
+    assert.equal(result.length, 2)
+    assert.equal(result[0], mockMiddleware1)
+    assert.equal(result[1], mockMiddleware2)
+  })
+
+  test('should combine function middleware only', () => {
+    const mockMiddleware1: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+    const mockMiddleware2: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        funcMiddleware: [mockMiddleware1, mockMiddleware2],
+      }
+    )
+
+    assert.equal(result.length, 2)
+    assert.equal(result[0], mockMiddleware1)
+    assert.equal(result[1], mockMiddleware2)
+  })
+
+  test('should execute middleware in correct order: wiringTags → wiringMiddleware → funcMiddleware → funcTags', () => {
+    // Setup tagged middleware
+    const wiringTagMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+    const funcTagMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('wiringTag', [wiringTagMiddleware])
+    addMiddleware('funcTag', [funcTagMiddleware])
+
+    const wiringMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+    const funcMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    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
+    assert.equal(result[0], wiringTagMiddleware) // wiringTags first
+    assert.equal(result[1], wiringMiddleware) // wiringMiddleware second
+    assert.equal(result[2], funcMiddleware) // funcMiddleware third
+    assert.equal(result[3], funcTagMiddleware) // funcTags last
+  })
+
+  test('should handle wiring tags only', () => {
+    const taggedMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('testTag', [taggedMiddleware])
+
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringTags: ['testTag'],
+      }
+    )
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0], taggedMiddleware)
+  })
+
+  test('should handle function tags only', () => {
+    const taggedMiddleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('funcTestTag', [taggedMiddleware])
+
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        funcTags: ['funcTestTag'],
+      }
+    )
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0], taggedMiddleware)
+  })
+
+  test('should handle multiple tags', () => {
+    const middleware1: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+    const middleware2: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('tag1', [middleware1])
+    addMiddleware('tag2', [middleware2])
+
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringTags: ['tag1', 'tag2'],
+      }
+    )
+
+    assert.equal(result.length, 2)
+    assert.equal(result[0], middleware1)
+    assert.equal(result[1], middleware2)
+  })
+
+  test('should ignore non-existent tags', () => {
+    const middleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('existingTag', [middleware])
+
+    const result = combineMiddleware(
+      PikkuWiringTypes.http,
+      Math.random().toString(),
+      {
+        wiringTags: ['existingTag', 'nonExistentTag'],
+        funcTags: ['anotherNonExistentTag'],
+      }
+    )
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0], middleware)
+  })
+})
+
+describe('runMiddleware', () => {
+  test('should deduplicate middleware using Set', async () => {
+    const executionOrder: string[] = []
+
+    const middleware1: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('middleware1')
+      await next()
+    }
+
+    const middleware2: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('middleware2')
+      await next()
+    }
+
+    await runMiddleware(
+      {} as any,
+      {} as any,
+      combineMiddleware(PikkuWiringTypes.rpc, Math.random().toString(), {
+        wiringMiddleware: [middleware1, middleware2, middleware1, middleware2],
+      }),
+      async () => {
+        executionOrder.push('main')
+      }
+    )
+
+    // Should only execute each middleware once
+    assert.deepEqual(executionOrder, ['middleware1', 'middleware2', 'main'])
+  })
+
+  test('should execute middleware in correct order', async () => {
+    const executionOrder: string[] = []
+
+    const middleware1: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('start1')
+      await next()
+      executionOrder.push('end1')
+    }
+
+    const middleware2: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('start2')
+      await next()
+      executionOrder.push('end2')
+    }
+
+    await runMiddleware(
+      {} as any,
+      {} as any,
+      [middleware1, middleware2],
+      async () => {
+        executionOrder.push('main')
+      }
+    )
+
+    assert.deepEqual(executionOrder, [
+      'start1',
+      'start2',
+      'main',
+      'end2',
+      'end1',
+    ])
+  })
+
+  test('should work with empty middleware array', async () => {
+    let mainExecuted = false
+
+    await runMiddleware({} as any, {} as any, [], async () => {
+      mainExecuted = true
+    })
+
+    assert.equal(mainExecuted, true)
+  })
+
+  test('should work without main function', async () => {
+    const executionOrder: string[] = []
+
+    const middleware: CorePikkuMiddleware = async (
+      services,
+      interaction,
+      next
+    ) => {
+      executionOrder.push('middleware')
+      await next()
+    }
+
+    await runMiddleware({} as any, {} as any, [middleware])
+
+    assert.deepEqual(executionOrder, ['middleware'])
+  })
+})

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,16 +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) {
@@ -124,30 +124,77 @@ 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.
+ * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
  * This helper function gets middleware for tags and combines it with any
- * wiring-specific middleware, avoiding the need for manual spreading.
+ * wiring-specific middleware and function-level middleware, avoiding the need for manual spreading.
  *
- * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
- * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @param {object} options - Configuration object for combining middleware.
+ * @param {CorePikkuMiddleware[] | undefined} options.wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} options.wiringTags - Array of wiring-level tags to look up middleware for.
+ * @param {CorePikkuMiddleware[] | undefined} options.funcMiddleware - Function-level middleware.
+ * @param {string[] | undefined} options.funcTags - Array of function-level tags to look up middleware for.
  * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
  *
  * @example
  * ```typescript
- * // Instead of:
- * const taggedMiddleware = getMiddlewareForTags(tags)
- * const combined = [...taggedMiddleware, ...(middleware || [])]
- *
- * // Use:
- * const combined = addMiddlewareForTags(middleware, tags)
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
  * ```
  */
-export const addMiddlewareForTags = (
-  wiringMiddleware?: CorePikkuMiddleware[],
-  tags?: string[]
-): CorePikkuMiddleware[] => {
-  const taggedMiddleware = getMiddlewareForTags(tags)
-  return [...taggedMiddleware, ...(wiringMiddleware || [])]
+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
+  // 3) funcMiddleware
+  // 4) funcTags middleware
+  const wiringTaggedMiddleware = getMiddlewareForTags(wiringTags)
+  const funcTaggedMiddleware = getMiddlewareForTags(funcTags)
+
+  middlewareCache[wireType][uid] = freezeDedupe([
+    ...(httpMiddleware || []),
+    ...wiringTaggedMiddleware,
+    ...(wiringMiddleware || []),
+    ...(funcMiddleware || []),
+    ...funcTaggedMiddleware,
+  ]) as readonly CorePikkuMiddleware[]
+
+  return middlewareCache[wireType][uid]
 }