@pikku/core 0.9.5 → 0.9.7

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## 0.9.0
 
+## 0.9.7
+
+### Patch Changes
+
+- 85a1c76: fix: fixing delete method return type in local-content and ignoring body (for now) in delete calls
+
+## 0.9.6
+
+### Patch Changes
+
+- 6059c87: refactor: move PikkuPermission to pikkuPermission and same for middleware for api consistency to to improve future features
+- 6db63bb: perf: changing http meta to a lookup map to reduce loops
+- 74f8634: perf: moving router externally to be able to swap them out, similar to hono
+- 766fef1: feat: adding caching for middleware and permissions
+
 ## 0.9.5
 
 ### Patch Changes

package/dist/function/function-runner.d.ts

@@ -1,8 +1,8 @@
-import { CoreServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
+import { CoreServices, CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes } from '../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from './functions.types.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any> | CorePikkuFunctionSessionless<any, any> | CorePikkuFunction<any, any>) => void;
 export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, data: In, session?: CoreUserSession) => Promise<Out>;
-export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;

package/dist/function/function-runner.js

@@ -16,7 +16,7 @@ export const runPikkuFuncDirectly = async (funcName, allServices, data, session)
     }
     return (await funcConfig.func(allServices, data, session));
 };
-export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags = [], }) => {
+export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags = [], }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -39,7 +39,7 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
         }
     }
     // Run permission checks in the specified order
-    await runPermissions({
+    await runPermissions(wireType, wireId, {
         wiringTags: tags,
         wiringPermissions,
         funcTags: funcConfig.tags,
@@ -49,7 +49,7 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
         session,
     });
     // Combine all middleware: wiring tags → wiring middleware → func middleware → func tags
-    const allMiddleware = combineMiddleware({
+    const allMiddleware = combineMiddleware(wireType, wireId, {
         wiringTags: tags,
         wiringMiddleware,
         funcMiddleware: funcConfig.middleware,

package/dist/function/functions.types.d.ts

@@ -34,6 +34,10 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
 export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
+/**
+ * Factory function for creating permissions with tree-shaking support
+ */
+export declare const pikkuPermission: <In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession>(permission: CorePikkuPermission<In, Services, Session>) => CorePikkuPermission<In, Services, Session>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
 export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>> = {
     name?: string;

package/dist/function/functions.types.js

@@ -1 +1,6 @@
-export {};
+/**
+ * Factory function for creating permissions with tree-shaking support
+ */
+export const pikkuPermission = (permission) => {
+    return permission;
+};

package/dist/index.d.ts

@@ -18,11 +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, combineMiddleware, } from './middleware-runner.js';
-export { addPermission, getPermissionsForTags, runPermissions, } 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/dist/index.js

@@ -18,11 +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, combineMiddleware, } from './middleware-runner.js';
-export { addPermission, getPermissionsForTags, runPermissions, } 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/dist/middleware-runner.d.ts

@@ -1,5 +1,5 @@
 import { UserSessionService } from './services/user-session-service.js';
-import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './types/core.types.js';
+import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware, PikkuWiringTypes } from './types/core.types.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -19,7 +19,7 @@ import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './
  */
 export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices & {
     userSession?: UserSessionService<any>;
-}, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
+}, interaction: PikkuInteraction, middlewares: readonly Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
 /**
  * Adds global middleware for a specific tag.
  *
@@ -84,9 +84,10 @@ export declare const getMiddlewareForTags: (tags?: string[]) => CorePikkuMiddlew
  * })
  * ```
  */
-export declare const combineMiddleware: ({ wiringMiddleware, wiringTags, funcMiddleware, funcTags, }?: {
+export declare const combineMiddleware: (wireType: PikkuWiringTypes, uid: string, { httpMiddleware, wiringMiddleware, wiringTags, funcMiddleware, funcTags, }?: {
+    httpMiddleware?: CorePikkuMiddleware[];
     wiringMiddleware?: CorePikkuMiddleware[];
     wiringTags?: string[];
     funcMiddleware?: CorePikkuMiddleware[];
     funcTags?: string[];
-}) => CorePikkuMiddleware[];
+}) => readonly CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -1,4 +1,6 @@
+import { 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.
  *
@@ -18,11 +20,10 @@ import { pikkuState } from './pikku-state.js';
  */
 export const runMiddleware = async (services, interaction, middlewares, main) => {
     // Deduplicate middleware using Set to avoid running the same middleware multiple times
-    const uniqueMiddleware = Array.from(new Set(middlewares));
     let result;
     const dispatch = async (index) => {
-        if (uniqueMiddleware && index < uniqueMiddleware.length) {
-            return await uniqueMiddleware[index](services, interaction, () => dispatch(index + 1));
+        if (middlewares && index < middlewares.length) {
+            return await middlewares[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -93,6 +94,14 @@ export const getMiddlewareForTags = (tags) => {
     }
     return applicableMiddleware;
 };
+const middlewareCache = {
+    [PikkuWiringTypes.http]: {},
+    [PikkuWiringTypes.rpc]: {},
+    [PikkuWiringTypes.channel]: {},
+    [PikkuWiringTypes.queue]: {},
+    [PikkuWiringTypes.scheduler]: {},
+    [PikkuWiringTypes.mcp]: {},
+};
 /**
  * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
@@ -116,7 +125,10 @@ export const getMiddlewareForTags = (tags) => {
  * })
  * ```
  */
-export const combineMiddleware = ({ wiringMiddleware, wiringTags, funcMiddleware, funcTags, } = {}) => {
+export const combineMiddleware = (wireType, uid, { httpMiddleware, wiringMiddleware, wiringTags, funcMiddleware, funcTags, } = {}) => {
+    if (middlewareCache[wireType][uid]) {
+        return middlewareCache[wireType][uid];
+    }
     // Run middleware in specific order:
     // 1) wiringTags middleware
     // 2) wiringMiddleware
@@ -124,10 +136,12 @@ export const combineMiddleware = ({ wiringMiddleware, wiringTags, funcMiddleware
     // 4) funcTags middleware
     const wiringTaggedMiddleware = getMiddlewareForTags(wiringTags);
     const funcTaggedMiddleware = getMiddlewareForTags(funcTags);
-    return [
+    middlewareCache[wireType][uid] = freezeDedupe([
+        ...(httpMiddleware || []),
         ...wiringTaggedMiddleware,
         ...(wiringMiddleware || []),
         ...(funcMiddleware || []),
         ...funcTaggedMiddleware,
-    ];
+    ]);
+    return middlewareCache[wireType][uid];
 };

package/dist/permissions.d.ts

@@ -1,4 +1,4 @@
-import { CoreServices, CoreUserSession } from './types/core.types.js';
+import { CoreServices, CoreUserSession, PikkuWiringTypes } from './types/core.types.js';
 import { CorePermissionGroup, CorePikkuPermission } from './function/functions.types.js';
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
@@ -47,7 +47,7 @@ export declare const addPermission: (tag: string, permissions: CorePermissionGro
  * const permissions = getPermissionsForTags(['api', 'auth'])
  * ```
  */
-export declare const getPermissionsForTags: (tags?: string[]) => Array<CorePermissionGroup | CorePikkuPermission>;
+export declare const getPermissionsForTags: (tags?: string[]) => readonly (CorePermissionGroup | CorePikkuPermission)[];
 /**
  * Runs permission checks in the specified order:
  * 1) wiring tag permissions - at least one must pass if any exist
@@ -55,7 +55,7 @@ export declare const getPermissionsForTags: (tags?: string[]) => Array<CorePermi
  * 3) function tag permissions - at least one must pass if any exist
  * 4) function permissions - must pass if defined
  */
-export declare const runPermissions: ({ wiringTags, wiringPermissions, funcTags, funcPermissions, allServices, data, session, }: {
+export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, { wiringTags, wiringPermissions, funcTags, funcPermissions, allServices, data, session, }: {
     wiringTags?: string[];
     wiringPermissions?: CorePermissionGroup;
     funcTags?: string[];

package/dist/permissions.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes, } from './types/core.types.js';
 import { pikkuState } from './pikku-state.js';
 import { ForbiddenError } from './errors/errors.js';
 /**
@@ -63,6 +64,7 @@ export const addPermission = (tag, permissions) => {
     }
     permissionsStore[tag] = permissions;
 };
+const EMPTY = [];
 /**
  * Retrieves permissions for a given set of tags.
  *
@@ -80,7 +82,7 @@ export const addPermission = (tag, permissions) => {
  */
 export const getPermissionsForTags = (tags) => {
     if (!tags || tags.length === 0) {
-        return [];
+        return EMPTY;
     }
     const permissionsStore = pikkuState('misc', 'permissions');
     const applicablePermissions = [];
@@ -98,6 +100,14 @@ export const getPermissionsForTags = (tags) => {
     }
     return applicablePermissions;
 };
+const permissionCache = {
+    [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
@@ -105,10 +115,18 @@ export const getPermissionsForTags = (tags) => {
  * 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, }) => {
+export const runPermissions = async (wireType, uid, { wiringTags, wiringPermissions, funcTags, funcPermissions, allServices, data, session, }) => {
+    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) {
@@ -119,18 +137,20 @@ export const runPermissions = async ({ wiringTags, wiringPermissions, funcTags,
             }
         }
         if (!permissioned) {
-            throw new ForbiddenError('Permission denied - wiring tag permissions');
+            allServices.logger.debug('Permission denied - wiring tag permissions');
+            throw new ForbiddenError('Permission denied');
         }
     }
     // 2. Wiring permissions - must pass if defined
     if (wiringPermissions) {
         permissioned = await verifyPermissions(wiringPermissions, allServices, data, 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) {
@@ -141,14 +161,16 @@ export const runPermissions = async ({ wiringTags, wiringPermissions, funcTags,
             }
         }
         if (!permissioned) {
-            throw new ForbiddenError('Permission denied - function tag permissions');
+            allServices.logger.debug('Permission denied - function tag permissions');
+            throw new ForbiddenError('Permission denied');
         }
     }
     // 4. Function permissions - must pass if defined
     if (funcPermissions) {
         permissioned = await verifyPermissions(funcPermissions, allServices, data, session);
         if (!permissioned) {
-            throw new ForbiddenError('Permission denied - function permissions');
+            allServices.logger.debug('Permission denied - function permissions');
+            throw new ForbiddenError('Permission denied');
         }
     }
 };

package/dist/pikku-state.d.ts

@@ -19,10 +19,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;
     };

package/dist/pikku-state.js

@@ -9,9 +9,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/dist/schema.js

@@ -27,13 +27,15 @@ const validateAllSchemasLoaded = (logger, schemaService) => {
     const routesMeta = pikkuState('http', 'meta');
     const validators = schemaService.getSchemaNames();
     const missingSchemas = [];
-    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) {
         logger.error(`Error: Failed to load schemas:\n.${missingSchemas.join('\n')}`);

package/dist/services/local-content.js

@@ -71,6 +71,7 @@ export class LocalContent {
         this.logger.debug(`deleting key: ${assetKey}`);
         try {
             await promises.unlink(`${this.config.localFileUploadPath}/${assetKey}`);
+            return true;
         }
         catch (e) {
             this.logger.error(`Error deleting content ${assetKey}`, e);

package/dist/types/core.types.d.ts

@@ -106,6 +106,10 @@ export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
 export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
     userSession: UserSessionService<UserSession>;
 }, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+/**
+ * Factory function for creating middleware with tree-shaking support
+ */
+export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession>(middleware: CorePikkuMiddleware<SingletonServices, UserSession>) => CorePikkuMiddleware<SingletonServices, UserSession>;
 /**
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */

package/dist/types/core.types.js

@@ -7,3 +7,9 @@ export var PikkuWiringTypes;
     PikkuWiringTypes["queue"] = "queue";
     PikkuWiringTypes["mcp"] = "mcp";
 })(PikkuWiringTypes || (PikkuWiringTypes = {}));
+/**
+ * Factory function for creating middleware with tree-shaking support
+ */
+export const pikkuMiddleware = (middleware) => {
+    return middleware;
+};

package/dist/utils.d.ts

@@ -2,3 +2,4 @@ import { Logger } from './services/logger.js';
 export declare const closeSessionServices: (logger: Logger, sessionServices: Record<string, any>) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
+export declare const freezeDedupe: <T extends Function>(arr?: readonly T[] | T[] | undefined) => readonly T[];

package/dist/utils.js

@@ -28,3 +28,20 @@ export const isSerializable = (data) => {
         data instanceof Float32Array ||
         data instanceof Float64Array);
 };
+const EMPTY_ARRAY = Object.freeze([]);
+export const freezeDedupe = (arr) => {
+    if (!arr || arr.length === 0)
+        return EMPTY_ARRAY;
+    if (arr.length === 1)
+        return Object.freeze([arr[0]]);
+    const seen = new Set();
+    const out = [];
+    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/dist/wirings/channel/channel-handler.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
@@ -47,7 +48,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         const { pikkuFuncName } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
         const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
         const middleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
-        return await runPikkuFunc(pikkuFuncName, {
+        return await runPikkuFunc(PikkuWiringTypes.channel, channelConfig.name, pikkuFuncName, {
             getAllServices: () => ({
                 ...services,
                 channel: channelHandler.getChannel(),

package/dist/wirings/channel/channel-runner.d.ts

@@ -1,4 +1,5 @@
 import { UserSessionService } from '../../services/user-session-service.js';
+import { CorePikkuMiddleware } from '../../types/core.types.js';
 import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
  * Adds a channel and registers all functions referenced in it using the
@@ -11,4 +12,5 @@ export declare const openChannel: ({ route, singletonServices, coerceDataFromSch
     openingData: unknown;
     channelConfig: CoreChannel<unknown, any>;
     meta: ChannelMeta;
+    httpMiddleware: CorePikkuMiddleware[] | undefined;
 }>;

package/dist/wirings/channel/channel-runner.js

@@ -2,7 +2,7 @@ import { NotFoundError } from '../../errors/errors.js';
 import { addFunction } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
-import { match } from 'path-to-regexp';
+import { httpRouter } from '../http/routers/http-router.js';
 /**
  * Adds a channel and registers all functions referenced in it using the
  * function names already stored in the channel metadata
@@ -65,30 +65,28 @@ export const wireChannel = (channel) => {
     pikkuState('channel', 'channels').set(channel.name, channel);
 };
 const getMatchingChannelConfig = (request) => {
+    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 null;
+    return {
+        matchedPath,
+        params: matchedPath.params,
+        channelConfig,
+        schemaName: channelMeta.input,
+        meta: channelMeta,
+        httpMiddleware: matchedPath.middleware,
+    };
 };
 export const openChannel = async ({ route, singletonServices, coerceDataFromSchema = true, request, }) => {
     const matchingChannel = getMatchingChannelConfig(route);
@@ -96,7 +94,7 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         singletonServices.logger.info(`Channel not found: ${route}`);
         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);
     singletonServices.logger.info(`Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`);
@@ -108,5 +106,5 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         }
         await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, openingData);
     }
-    return { openingData, channelConfig, meta };
+    return { openingData, channelConfig, meta, httpMiddleware };
 };

package/dist/wirings/channel/local/local-channel-runner.js

@@ -3,6 +3,7 @@ import { createHTTPInteraction } from '../../http/http-runner.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
+import { PikkuWiringTypes } 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';
@@ -17,10 +18,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         http = createHTTPInteraction(request, response);
         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,
@@ -77,9 +78,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, combineMiddleware({
+    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
         wiringMiddleware: channelConfig.middleware,
         wiringTags: channelConfig.tags,
+        httpMiddleware,
     }), main);
     return channelHandler;
 };

package/dist/wirings/channel/serverless/serverless-channel-runner.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes } from '../../../types/core.types.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
@@ -34,7 +35,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response);
     }
     const userSession = new PikkuUserSessionService(channelStore, channelId);
-    const { channelConfig, openingData, meta } = await openChannel({
+    const { channelConfig, openingData, meta, httpMiddleware } = await openChannel({
         channelId,
         createSessionServices,
         request,
@@ -76,9 +77,10 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, combineMiddleware({
+    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
         wiringMiddleware: channelConfig.middleware,
         wiringTags: channelConfig.tags,
+        httpMiddleware,
     }), main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {