@pikku/core 0.9.4 → 0.9.6

package/src/pikku-state.ts

@@ -10,7 +10,11 @@ import {
   ScheduledTasksMeta,
 } from './wirings/scheduler/scheduler.types.js'
 import { ErrorDetails, PikkuError } from './errors/error-handler.js'
-import { CorePikkuFunctionConfig } from './function/functions.types.js'
+import {
+  CorePermissionGroup,
+  CorePikkuFunctionConfig,
+  CorePikkuPermission,
+} from './function/functions.types.js'
 import {
   queueWorkersMeta,
   CoreQueueWorker,
@@ -40,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
   }
@@ -68,7 +73,7 @@ interface PikkuState {
     errors: Map<PikkuError, ErrorDetails>
     schemas: Map<string, any>
     middleware: Record<string, CorePikkuMiddleware[]>
-    permissions: Record<string, any[]>
+    permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>
   }
 }
 
@@ -83,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(),
@@ -109,9 +115,9 @@ export const resetPikkuState = () => {
     },
     misc: {
       errors: globalThis.pikkuState?.misc?.errors || new Map(),
-      schemas: globalThis.pikkuState?.misc?.schema || new Map(),
-      middleware: globalThis.pikkuState?.misc?.middleware || {},
-      permissions: globalThis.pikkuState?.misc?.permissions || {},
+      schemas: new Map(),
+      middleware: {},
+      permissions: {},
     },
   } as PikkuState
 }

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

@@ -114,14 +114,13 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of interaction within Pikku and the outside world.
  */
-export type PikkuInteraction = Partial<{
-  http: PikkuHTTP
+export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
+  http: PikkuHTTP<In>
   mcp: PikkuMCP
   rpc: PikkuRPC
-  channel: PikkuChannel<unknown, unknown>
+  channel: PikkuChannel<unknown, Out>
   scheduledTask: PikkuScheduledTask
   queue: PikkuQueue
-  s
 }>
 
 /**
@@ -138,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,12 +8,9 @@ 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 {
-  addMiddlewareForTags,
-  runMiddleware,
-} from '../../../middleware-runner.js'
+import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js'
 import { PikkuUserSessionService } from '../../../services/user-session-service.js'
 import { PikkuHTTP } from '../../http/http.types.js'
 import { runPikkuFuncDirectly } from '../../../function/function-runner.js'
@@ -45,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,
@@ -149,7 +146,11 @@ export const runLocalChannel = async ({
       userSession,
     },
     { http },
-    addMiddlewareForTags(channelConfig.middleware, channelConfig.tags),
+    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'
@@ -12,10 +12,7 @@ import { createHTTPInteraction } from '../../http/http-runner.js'
 import { ChannelStore } from '../channel-store.js'
 import { handleHTTPError } from '../../../handle-error.js'
 import { PikkuUserSessionService } from '../../../services/user-session-service.js'
-import {
-  addMiddlewareForTags,
-  runMiddleware,
-} from '../../../middleware-runner.js'
+import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js'
 import { pikkuState } from '../../../pikku-state.js'
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js'
 import { PikkuHTTP } from '../../http/http.types.js'
@@ -88,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 {
@@ -149,7 +147,11 @@ export const runChannelConnect = async ({
       userSession,
     },
     { http },
-    addMiddlewareForTags(channelConfig.middleware, channelConfig.tags),
+    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,

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

@@ -12,8 +12,8 @@ import {
   CoreUserSession,
   CorePikkuMiddleware,
   SessionServices,
+  PikkuWiringTypes,
 } from '../../types/core.types.js'
-import { match } from 'path-to-regexp'
 import { MissingSessionError, NotFoundError } from '../../errors/errors.js'
 import {
   closeSessionServices,
@@ -24,7 +24,7 @@ import {
   PikkuUserSessionService,
   UserSessionService,
 } from '../../services/user-session-service.js'
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js'
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
 import { handleHTTPError } from '../../handle-error.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
@@ -32,6 +32,7 @@ import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js'
 import { PikkuChannel } from '../channel/channel.types.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { rpcService } from '../rpc/rpc-runner.js'
+import { httpRouter } from './routers/http-router.js'
 
 /**
  * Registers middleware either globally or for a specific route.
@@ -49,32 +50,20 @@ export const addHTTPMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   middleware?: PikkuMiddleware[]
 ) => {
   const middlewareStore = pikkuState('http', 'middleware')
+  let route = '*'
 
-  if (typeof routeOrMiddleware === 'string' && middleware) {
-    const route = routeOrMiddleware
-
-    // Remove existing entry for this route if it exists
-    const existingIndex = middlewareStore.findIndex(
-      (item) => item.route === route
-    )
-    if (existingIndex !== -1) {
-      middlewareStore.splice(existingIndex, 1)
-    }
-
-    middlewareStore.push({ route, middleware })
+  if (typeof routeOrMiddleware === 'string') {
+    route = routeOrMiddleware
+    middleware = middleware!
   } else {
-    // Handle global middleware
-    const existingIndex = middlewareStore.findIndex(
-      (item) => item.route === '*'
-    )
-    if (existingIndex !== -1) {
-      middlewareStore.splice(existingIndex, 1)
-    }
+    middleware = routeOrMiddleware
+  }
 
-    middlewareStore.push({
-      route: '*',
-      middleware: routeOrMiddleware as any,
-    })
+  const currentMiddleware = middlewareStore.get(route)
+  if (currentMiddleware) {
+    middlewareStore.set(route, [...currentMiddleware, ...middleware])
+  } else {
+    middlewareStore.set(route, middleware)
   }
 }
 
@@ -113,10 +102,7 @@ export const wireHTTP = <
   >
 ) => {
   const httpMeta = pikkuState('http', 'meta')
-  const routeMeta = httpMeta.find(
-    (meta) =>
-      meta.route === httpWiring.route && meta.method === httpWiring.method
-  )
+  const routeMeta = httpMeta[httpWiring.method][httpWiring.route]
   if (!routeMeta) {
     throw new Error('Route metadata not found')
   }
@@ -142,43 +128,29 @@ export const wireHTTP = <
  * @returns {Object | undefined} An object with matched route details or undefined if no match.
  */
 const getMatchingRoute = (requestType: string, requestPath: string) => {
-  const allRoutes = pikkuState('http', 'routes')
-  const middleware = pikkuState('http', 'middleware')
-  const routes = allRoutes.get(requestType.toLowerCase() as HTTPMethod)
-  if (!routes) {
-    return undefined
-  }
-  for (const route of routes.values()) {
-    // Generate a matching function from the route pattern
-    const matchFunc = match(`/${route.route}`.replace(/^\/\//, '/'), {
-      decode: decodeURIComponent,
-    })
-
-    // Attempt to match the request path
-    const matchedPath = matchFunc(requestPath.replace(/^\/\//, '/'))
-
-    if (matchedPath) {
-      // Aggregate global and route-specific middleware
-      const globalMiddleware = middleware
-        .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
-        .map((m) => m.middleware)
-        .flat()
-
-      const meta = pikkuState('http', 'meta').find(
-        (meta) => meta.route === route.route && meta.method === route.method
-      )
+  const matchedPath = httpRouter.match(
+    requestType.toLowerCase() as HTTPMethod,
+    requestPath
+  )
 
-      return {
-        matchedPath,
-        params: matchedPath.params,
-        route,
-        permissions: route.permissions,
-        middleware: [...globalMiddleware, ...(route.middleware || [])],
-        meta: meta!,
-      }
+  if (matchedPath) {
+    const route = pikkuState('http', 'routes')
+      .get(requestType.toLowerCase() as HTTPMethod)!
+      .get(matchedPath.route)!
+    const meta = pikkuState('http', 'meta')[
+      requestType.toLowerCase() as PikkuWiringTypes
+    ][route.route]
+
+    return {
+      matchedPath,
+      params: matchedPath.params,
+      route,
+      permissions: route.permissions,
+      httpMiddleware: matchedPath.middleware,
+      middleware: route.middleware,
+      meta: meta!,
     }
   }
-  return undefined
 }
 
 /**
@@ -251,7 +223,8 @@ const executeRouteWithMiddleware = async (
     matchedPath: any
     params: any
     route: CoreHTTPFunctionWiring<any, any, any>
-    middleware: any[]
+    httpMiddleware: CorePikkuMiddleware[] | undefined
+    middleware: CorePikkuMiddleware[] | undefined
     meta: HTTPWiringMeta
   },
   http: PikkuHTTP,
@@ -259,7 +232,8 @@ const executeRouteWithMiddleware = async (
     coerceDataFromSchema: boolean
   }
 ) => {
-  const { matchedPath, params, route, middleware, meta } = matchedRoute
+  const { matchedPath, params, route, httpMiddleware, middleware, meta } =
+    matchedRoute
   const {
     singletonServices,
     userSession,
@@ -347,14 +321,19 @@ const executeRouteWithMiddleware = async (
       })
     }
 
-    result = await runPikkuFunc(meta.pikkuFuncName, {
-      getAllServices,
-      session,
-      data,
-      permissions: route.permissions,
-      coerceDataFromSchema: options.coerceDataFromSchema,
-      tags: route.tags,
-    })
+    result = await runPikkuFunc(
+      PikkuWiringTypes.http,
+      `${meta.method}:${meta.route}`,
+      meta.pikkuFuncName,
+      {
+        getAllServices,
+        session,
+        data,
+        permissions: route.permissions,
+        coerceDataFromSchema: options.coerceDataFromSchema,
+        tags: route.tags,
+      }
+    )
 
     // Respond with either a binary or JSON response based on configuration
     if (route.returnsJSON === false) {
@@ -368,11 +347,20 @@ const executeRouteWithMiddleware = async (
     // http?.response?.end()
   }
 
+  // Get function config for middleware and tags
+  const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName)
+
   // Execute middleware, then run the main logic
   await runMiddleware(
     { ...singletonServices, userSession },
     { http },
-    addMiddlewareForTags(middleware, route.tags),
+    combineMiddleware(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, {
+      httpMiddleware,
+      wiringMiddleware: middleware,
+      wiringTags: route.tags,
+      funcMiddleware: funcConfig?.middleware,
+      funcTags: funcConfig?.tags,
+    }),
     runMain
   )
 
@@ -498,7 +486,8 @@ export const fetchData = async <In, Out>(
       ignoreMiddleware
         ? {
             ...matchedRoute,
-            middleware: [],
+            middleware: undefined,
+            httpMiddleware: undefined,
           }
         : matchedRoute,
       http!,