@pikku/core 0.9.5 → 0.9.6

package/src/permissions.test.ts

@@ -6,7 +6,11 @@ import {
   runPermissions,
 } from './permissions.js'
 import { resetPikkuState } from './pikku-state.js'
-import { CoreServices, CoreUserSession } from './types/core.types.js'
+import {
+  CoreServices,
+  CoreUserSession,
+  PikkuWiringTypes,
+} from './types/core.types.js'
 import { CorePermissionGroup } from './function/functions.types.js'
 
 beforeEach(() => {
@@ -160,7 +164,7 @@ describe('getPermissionsForTags', () => {
 describe('runPermissions', () => {
   test('should pass when no permissions are defined', async () => {
     // Should not throw
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       allServices: mockServices,
       data: {},
       session: mockSession,
@@ -176,7 +180,7 @@ describe('runPermissions', () => {
 
     addPermission('wiringTag', [wiringTagPermission])
 
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       wiringTags: ['wiringTag'],
       allServices: mockServices,
       data: {},
@@ -219,7 +223,7 @@ describe('runPermissions', () => {
       ],
     }
 
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       wiringTags: ['wiringTag'],
       wiringPermissions,
       funcTags: ['funcTag'],
@@ -245,7 +249,7 @@ describe('runPermissions', () => {
     addPermission('atLeastOneTestTag', [failingPermission, passingPermission])
 
     // Should not throw because at least one permission passes
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       wiringTags: ['atLeastOneTestTag'],
       allServices: mockServices,
       data: {},
@@ -260,14 +264,14 @@ describe('runPermissions', () => {
     addPermission('allFailTestTag', [failingPermission1, failingPermission2])
 
     await assert.rejects(
-      runPermissions({
+      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
         wiringTags: ['allFailTestTag'],
         allServices: mockServices,
         data: {},
         session: mockSession,
       }),
       {
-        message: 'Permission denied - wiring tag permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -278,14 +282,14 @@ describe('runPermissions', () => {
     }
 
     await assert.rejects(
-      runPermissions({
+      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
         wiringPermissions,
         allServices: mockServices,
         data: {},
         session: mockSession,
       }),
       {
-        message: 'Permission denied - wiring permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -296,14 +300,14 @@ describe('runPermissions', () => {
     addPermission('funcTag', [failingPermission])
 
     await assert.rejects(
-      runPermissions({
+      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
         funcTags: ['funcTag'],
         allServices: mockServices,
         data: {},
         session: mockSession,
       }),
       {
-        message: 'Permission denied - function tag permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -314,14 +318,14 @@ describe('runPermissions', () => {
     }
 
     await assert.rejects(
-      runPermissions({
+      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
         funcPermissions,
         allServices: mockServices,
         data: {},
         session: mockSession,
       }),
       {
-        message: 'Permission denied - function permissions',
+        message: 'Permission denied',
       }
     )
   })
@@ -346,7 +350,7 @@ describe('runPermissions', () => {
     }
 
     await assert.rejects(
-      runPermissions({
+      runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
         wiringTags: ['failingWiringTag'],
         wiringPermissions,
         allServices: mockServices,
@@ -365,7 +369,7 @@ describe('runPermissions', () => {
     addPermission('arrayTestTag', arrayPermission)
 
     // Should not throw because verifyPermissions handles array properly
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       wiringTags: ['arrayTestTag'],
       allServices: mockServices,
       data: {},
@@ -381,7 +385,7 @@ describe('runPermissions', () => {
     addPermission('objectTestTag', permissionGroup)
 
     // Should not throw because verifyPermissions handles objects properly
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       wiringTags: ['objectTestTag'],
       allServices: mockServices,
       data: {},
@@ -405,7 +409,7 @@ describe('runPermissions', () => {
 
     addPermission('paramTestTag', [testPermission])
 
-    await runPermissions({
+    await runPermissions(PikkuWiringTypes.rpc, Math.random().toString(), {
       wiringTags: ['paramTestTag'],
       allServices: mockServices,
       data: testData,

package/src/permissions.ts

@@ -1,4 +1,8 @@
-import { CoreServices, CoreUserSession } from './types/core.types.js'
+import {
+  CoreServices,
+  CoreUserSession,
+  PikkuWiringTypes,
+} from './types/core.types.js'
 import {
   CorePermissionGroup,
   CorePikkuPermission,
@@ -86,6 +90,8 @@ export const addPermission = (
   permissionsStore[tag] = permissions
 }
 
+const EMPTY: readonly (CorePermissionGroup | CorePikkuPermission)[] = []
+
 /**
  * Retrieves permissions for a given set of tags.
  *
@@ -103,9 +109,9 @@ export const addPermission = (
  */
 export const getPermissionsForTags = (
   tags?: string[]
-): Array<CorePermissionGroup | CorePikkuPermission> => {
+): readonly (CorePermissionGroup | CorePikkuPermission)[] => {
   if (!tags || tags.length === 0) {
-    return []
+    return EMPTY
   }
 
   const permissionsStore = pikkuState('misc', 'permissions')
@@ -128,6 +134,26 @@ export const getPermissionsForTags = (
   return applicablePermissions
 }
 
+const permissionCache: Record<
+  PikkuWiringTypes,
+  Partial<
+    Record<
+      string,
+      {
+        wiringTags: readonly (CorePermissionGroup | CorePikkuPermission)[]
+        funcTags: readonly (CorePermissionGroup | CorePikkuPermission)[]
+      }
+    >
+  >
+> = {
+  [PikkuWiringTypes.http]: {},
+  [PikkuWiringTypes.rpc]: {},
+  [PikkuWiringTypes.channel]: {},
+  [PikkuWiringTypes.queue]: {},
+  [PikkuWiringTypes.scheduler]: {},
+  [PikkuWiringTypes.mcp]: {},
+}
+
 /**
  * Runs permission checks in the specified order:
  * 1) wiring tag permissions - at least one must pass if any exist
@@ -135,27 +161,39 @@ export const getPermissionsForTags = (
  * 3) function tag permissions - at least one must pass if any exist
  * 4) function permissions - must pass if defined
  */
-export const runPermissions = async ({
-  wiringTags,
-  wiringPermissions,
-  funcTags,
-  funcPermissions,
-  allServices,
-  data,
-  session,
-}: {
-  wiringTags?: string[]
-  wiringPermissions?: CorePermissionGroup
-  funcTags?: string[]
-  funcPermissions?: CorePermissionGroup
-  allServices: CoreServices
-  data: any
-  session?: CoreUserSession
-}) => {
+export const runPermissions = async (
+  wireType: PikkuWiringTypes,
+  uid: string,
+  {
+    wiringTags,
+    wiringPermissions,
+    funcTags,
+    funcPermissions,
+    allServices,
+    data,
+    session,
+  }: {
+    wiringTags?: string[]
+    wiringPermissions?: CorePermissionGroup
+    funcTags?: string[]
+    funcPermissions?: CorePermissionGroup
+    allServices: CoreServices
+    data: any
+    session?: CoreUserSession
+  }
+) => {
+  let cachedPermission = permissionCache[wireType][uid]
+  if (!cachedPermission) {
+    cachedPermission = {
+      wiringTags: getPermissionsForTags(wiringTags),
+      funcTags: getPermissionsForTags(funcTags),
+    }
+    permissionCache[wireType][uid] = cachedPermission
+  }
   let permissioned = true
 
   // 1. Wiring tag permissions - at least one must pass if any exist
-  const wiringTaggedPermissions = getPermissionsForTags(wiringTags || [])
+  const wiringTaggedPermissions = cachedPermission.wiringTags
   if (wiringTaggedPermissions.length > 0) {
     permissioned = false // Start false, need at least one to pass
     for (const permissions of wiringTaggedPermissions) {
@@ -171,7 +209,8 @@ export const runPermissions = async ({
       }
     }
     if (!permissioned) {
-      throw new ForbiddenError('Permission denied - wiring tag permissions')
+      allServices.logger.debug('Permission denied - wiring tag permissions')
+      throw new ForbiddenError('Permission denied')
     }
   }
 
@@ -184,12 +223,13 @@ export const runPermissions = async ({
       session
     )
     if (!permissioned) {
-      throw new ForbiddenError('Permission denied - wiring permissions')
+      allServices.logger.debug('Permission denied - wiring permissions')
+      throw new ForbiddenError('Permission denied')
     }
   }
 
   // 3. Function tag permissions - at least one must pass if any exist
-  const funcTaggedPermissions = getPermissionsForTags(funcTags || [])
+  const funcTaggedPermissions = cachedPermission.funcTags
   if (funcTaggedPermissions.length > 0) {
     permissioned = false // Start false, need at least one to pass
     for (const permissions of funcTaggedPermissions) {
@@ -205,7 +245,8 @@ export const runPermissions = async ({
       }
     }
     if (!permissioned) {
-      throw new ForbiddenError('Permission denied - function tag permissions')
+      allServices.logger.debug('Permission denied - function tag permissions')
+      throw new ForbiddenError('Permission denied')
     }
   }
 
@@ -218,7 +259,8 @@ export const runPermissions = async ({
       session
     )
     if (!permissioned) {
-      throw new ForbiddenError('Permission denied - function permissions')
+      allServices.logger.debug('Permission denied - function permissions')
+      throw new ForbiddenError('Permission denied')
     }
   }
 }

package/src/pikku-state.ts

@@ -44,7 +44,8 @@ interface PikkuState {
     >
   }
   http: {
-    middleware: Array<{ route: string; middleware: CorePikkuMiddleware[] }>
+    middleware: Map<string, CorePikkuMiddleware<any, any>[]>
+    permissions: Map<string, CorePermissionGroup | CorePikkuPermission[]>
     routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>
     meta: HTTPWiringsMeta
   }
@@ -87,9 +88,10 @@ export const resetPikkuState = () => {
       files: new Map(),
     },
     http: {
-      middleware: [],
+      permissions: new Map(),
+      middleware: new Map(),
       routes: new Map(),
-      meta: [],
+      meta: {},
     },
     channel: {
       channels: new Map(),

package/src/schema.ts

@@ -40,13 +40,15 @@ const validateAllSchemasLoaded = (
 
   const missingSchemas: string[] = []
 
-  for (const route of routesMeta) {
-    const inputs = pikkuState('function', 'meta')[route.pikkuFuncName]?.inputs
-    const input = inputs?.[0]
-    if (!input || validators.has(input)) {
-      continue
+  for (const routePaths of Object.values(routesMeta)) {
+    for (const meta of Object.values(routePaths)) {
+      const inputs = pikkuState('function', 'meta')[meta.pikkuFuncName]?.inputs
+      const input = inputs?.[0]
+      if (!input || validators.has(input)) {
+        continue
+      }
+      missingSchemas.push(input)
     }
-    missingSchemas.push(input)
   }
 
   if (missingSchemas.length > 0) {

package/src/types/core.types.ts

@@ -137,6 +137,18 @@ export type CorePikkuMiddleware<
   next: () => Promise<void>
 ) => Promise<void>
 
+/**
+ * Factory function for creating middleware with tree-shaking support
+ */
+export const pikkuMiddleware = <
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  UserSession extends CoreUserSession = CoreUserSession,
+>(
+  middleware: CorePikkuMiddleware<SingletonServices, UserSession>
+): CorePikkuMiddleware<SingletonServices, UserSession> => {
+  return middleware
+}
+
 /**
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */

package/src/utils.ts

@@ -38,3 +38,22 @@ export const isSerializable = (data: any): boolean => {
     data instanceof Float64Array
   )
 }
+
+const EMPTY_ARRAY = Object.freeze([])
+
+export const freezeDedupe = <T extends Function>(
+  arr?: readonly T[] | T[] | undefined
+): readonly T[] => {
+  if (!arr || arr.length === 0) return EMPTY_ARRAY
+  if (arr.length === 1) return Object.freeze([arr[0]!])
+  const seen = new Set<T>()
+  const out: T[] = []
+  for (let i = 0; i < arr.length; i++) {
+    const fn = arr[i]!
+    if (!seen.has(fn)) {
+      seen.add(fn)
+      out.push(fn)
+    }
+  }
+  return Object.freeze(out)
+}

package/src/wirings/channel/channel-handler.ts

@@ -2,6 +2,7 @@ import {
   CoreServices,
   JSONValue,
   CoreUserSession,
+  PikkuWiringTypes,
 } from '../../types/core.types.js'
 import {
   ChannelMessageMeta,
@@ -98,17 +99,22 @@ export const processMessageHandlers = (
     const middleware =
       typeof onMessage === 'function' ? [] : onMessage.middleware
 
-    return await runPikkuFunc(pikkuFuncName, {
-      getAllServices: () => ({
-        ...services,
-        channel: channelHandler.getChannel(),
-      }),
-      data,
-      session,
-      permissions,
-      middleware,
-      tags: channelConfig.tags,
-    })
+    return await runPikkuFunc(
+      PikkuWiringTypes.channel,
+      channelConfig.name,
+      pikkuFuncName,
+      {
+        getAllServices: () => ({
+          ...services,
+          channel: channelHandler.getChannel(),
+        }),
+        data,
+        session,
+        permissions,
+        middleware,
+        tags: channelConfig.tags,
+      }
+    )
   }
 
   const onMessage = async (rawData): Promise<unknown> => {

package/src/wirings/channel/channel-runner.ts

@@ -3,13 +3,14 @@ import { addFunction } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js'
 import { UserSessionService } from '../../services/user-session-service.js'
+import { CorePikkuMiddleware } from '../../types/core.types.js'
+import { httpRouter } from '../http/routers/http-router.js'
 import {
   ChannelMeta,
   CoreChannel,
   RunChannelOptions,
   RunChannelParams,
 } from './channel.types.js'
-import { match } from 'path-to-regexp'
 
 /**
  * Adds a channel and registers all functions referenced in it using the
@@ -91,30 +92,33 @@ export const wireChannel = <
 }
 
 const getMatchingChannelConfig = (request: string) => {
+  const matchedPath = httpRouter.match('get', request)
+  if (!matchedPath) {
+    return null
+  }
+
+  const meta = pikkuState('channel', 'meta')
+  const channelMeta = Object.values(meta).find(
+    (channelConfig) => channelConfig.route === matchedPath.route
+  )
+  if (!channelMeta) {
+    return null
+  }
+
   const channels = pikkuState('channel', 'channels')
-  const channelsMeta = pikkuState('channel', 'meta')
-  for (const channelConfig of channels.values()) {
-    const cleanedRoute = channelConfig.route.replace(/^\/\//, '/')
-    const cleanedRequest = request.replace(/^\/\//, '/')
-    const matchFunc = match(cleanedRoute, {
-      decode: decodeURIComponent,
-    })
-    const matchedPath = matchFunc(cleanedRequest)
-    if (matchedPath) {
-      const channelMeta = channelsMeta[channelConfig.name]
-      if (!channelMeta) {
-        throw new Error(`Channel ${channelConfig.name} not found in metadata`)
-      }
-      return {
-        matchedPath,
-        params: matchedPath.params,
-        channelConfig,
-        schemaName: channelMeta.input,
-        meta: channelMeta,
-      }
-    }
+  const channelConfig = channels.get(channelMeta.name)
+  if (!channelConfig) {
+    return null
+  }
+
+  return {
+    matchedPath,
+    params: matchedPath.params,
+    channelConfig,
+    schemaName: channelMeta.input,
+    meta: channelMeta,
+    httpMiddleware: matchedPath.middleware,
   }
-  return null
 }
 
 export const openChannel = async ({
@@ -129,6 +133,7 @@ export const openChannel = async ({
   openingData: unknown
   channelConfig: CoreChannel<unknown, any>
   meta: ChannelMeta
+  httpMiddleware: CorePikkuMiddleware[] | undefined
 }> => {
   const matchingChannel = getMatchingChannelConfig(route)
   if (!matchingChannel) {
@@ -136,7 +141,8 @@ export const openChannel = async ({
     throw new NotFoundError(`Channel not found: ${route}`)
   }
 
-  const { params, channelConfig, schemaName, meta } = matchingChannel
+  const { params, channelConfig, schemaName, meta, httpMiddleware } =
+    matchingChannel
 
   const requiresSession = channelConfig.auth !== false
   request?.setParams(params)
@@ -159,5 +165,5 @@ export const openChannel = async ({
     )
   }
 
-  return { openingData, channelConfig, meta }
+  return { openingData, channelConfig, meta, httpMiddleware }
 }

package/src/wirings/channel/local/local-channel-runner.test.ts

@@ -10,6 +10,7 @@ import {
   PikkuQuery,
 } from '../../http/http.types.js'
 import { SerializeOptions } from 'cookie'
+import { httpRouter } from '../../http/routers/http-router.js'
 
 /**
  * Minimal stubs for dependencies that runChannel expects.
@@ -139,6 +140,9 @@ test('runChannel should return a channel handler if channel matches and no auth
     auth: false,
   })
 
+  // Initialize router after adding channel (for tests)
+  httpRouter.initialize()
+
   const result = await runLocalChannel({
     singletonServices: mockSingletonServices,
     channelId: 'test-channel-id',

package/src/wirings/channel/local/local-channel-runner.ts

@@ -8,7 +8,7 @@ import {
   RunChannelParams,
 } from '../channel.types.js'
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
-import { SessionServices } from '../../../types/core.types.js'
+import { PikkuWiringTypes, SessionServices } from '../../../types/core.types.js'
 import { handleHTTPError } from '../../../handle-error.js'
 import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js'
 import { PikkuUserSessionService } from '../../../services/user-session-service.js'
@@ -42,9 +42,9 @@ export const runLocalChannel = async ({
     route = http?.request?.path()
   }
 
-  let openingData, channelConfig, meta
+  let openingData, channelConfig, meta, httpMiddleware
   try {
-    ;({ openingData, channelConfig, meta } = await openChannel({
+    ;({ openingData, channelConfig, meta, httpMiddleware } = await openChannel({
       channelId,
       createSessionServices,
       respondWith404,
@@ -146,9 +146,10 @@ export const runLocalChannel = async ({
       userSession,
     },
     { http },
-    combineMiddleware({
+    combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
       wiringMiddleware: channelConfig.middleware,
       wiringTags: channelConfig.tags,
+      httpMiddleware,
     }),
     main
   )

package/src/wirings/channel/serverless/serverless-channel-runner.ts

@@ -1,4 +1,4 @@
-import { SessionServices } from '../../../types/core.types.js'
+import { PikkuWiringTypes, SessionServices } from '../../../types/core.types.js'
 import { closeSessionServices } from '../../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import { openChannel } from '../channel-runner.js'
@@ -85,15 +85,16 @@ export const runChannelConnect = async ({
 
   const userSession = new PikkuUserSessionService(channelStore, channelId)
 
-  const { channelConfig, openingData, meta } = await openChannel({
-    channelId,
-    createSessionServices,
-    request,
-    route,
-    singletonServices,
-    coerceDataFromSchema,
-    userSession,
-  })
+  const { channelConfig, openingData, meta, httpMiddleware } =
+    await openChannel({
+      channelId,
+      createSessionServices,
+      request,
+      route,
+      singletonServices,
+      coerceDataFromSchema,
+      userSession,
+    })
 
   const main = async () => {
     try {
@@ -146,9 +147,10 @@ export const runChannelConnect = async ({
       userSession,
     },
     { http },
-    combineMiddleware({
+    combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
       wiringMiddleware: channelConfig.middleware,
       wiringTags: channelConfig.tags,
+      httpMiddleware,
     }),
     main
   )

package/src/wirings/http/http-runner.test.ts

@@ -9,6 +9,7 @@ import {
   PikkuMockResponse,
 } from '../channel/local/local-channel-runner.test.js'
 import { addFunction } from '../../function/function-runner.js'
+import { httpRouter } from './routers/http-router.js'
 
 const sessionMiddleware: CorePikkuMiddleware = async (services, _, next) => {
   services.userSession.set({ userId: 'test' } as any)
@@ -22,13 +23,21 @@ const setHTTPFunctionMap = (func: any) => {
       services: ['userSession'],
     },
   } as any)
-  pikkuState('http', 'meta', [
-    {
-      pikkuFuncName: 'pikku_func_name',
-      route: 'test',
-      method: 'get',
+  pikkuState('http', 'meta', {
+    get: {
+      test: {
+        pikkuFuncName: 'pikku_func_name',
+        route: 'test',
+        method: 'get',
+      },
     },
-  ])
+    post: {},
+    delete: {},
+    patch: {},
+    head: {},
+    put: {},
+    options: {},
+  })
   addFunction('pikku_func_name', { func })
 }
 
@@ -85,6 +94,9 @@ describe('fetch', () => {
       middleware: [sessionMiddleware],
     })
 
+    // Initialize router after adding route (for tests)
+    httpRouter.initialize()
+
     const result = await fetch(request, {
       singletonServices,
       createSessionServices,