@pikku/core 0.9.3 → 0.9.5

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## 0.9.0
 
+## 0.9.5
+
+### Patch Changes
+
+- 7e1f5b3: feat: implement ordered middleware and permission execution system
+
+  ## New Features
+
+  ### Ordered Execution System
+
+  Both middleware and permissions now execute in a specific hierarchical order:
+
+  1. **Wiring Tags** - Tag-based middleware/permissions from wiring level (e.g., HTTP route tags)
+  2. **Wiring Middleware/Permissions** - Direct wiring-level middleware/permissions
+  3. **Function Middleware** - Function-level middleware
+  4. **Function Tags** - Tag-based middleware/permissions from function level
+
+- b443405: feat: adding middleware and functions by tags
+
+## 0.9.4
+
+### Patch Changes
+
+- c18800d: feat: adding queue and scheduledTask to interactions
+
 ## 0.9.3
 
 ### Patch Changes

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

@@ -2,11 +2,12 @@ import { CoreServices, CoreUserSession, CorePikkuMiddleware } from '../types/cor
 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: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;
     permissions?: CorePermissionGroup;
     middleware?: CorePikkuMiddleware[];
     coerceDataFromSchema?: boolean;
+    tags?: string[];
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '../errors/errors.js';
-import { runMiddleware } from '../middleware-runner.js';
-import { verifyPermissions } from '../permissions.js';
+import { runMiddleware, combineMiddleware } from '../middleware-runner.js';
+import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 export const addFunction = (funcName, funcConfig) => {
@@ -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: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }) => {
+export const runPikkuFunc = async (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}`);
@@ -38,22 +38,29 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
             coerceTopLevelDataFromSchema(inputSchemaName, data);
         }
     }
-    let permissioned = true;
-    if (funcConfig.permissions) {
-        permissioned = await verifyPermissions(funcConfig.permissions, allServices, data, session);
-    }
-    if (!permissioned && transportPermissions) {
-        permissioned = await verifyPermissions(transportPermissions, allServices, data, session);
-    }
-    if (permissioned === false) {
-        throw new ForbiddenError('Permission denied');
-    }
-    if (transportMiddleware || funcConfig.middleware) {
+    // Run permission checks in the specified order
+    await runPermissions({
+        wiringTags: tags,
+        wiringPermissions,
+        funcTags: funcConfig.tags,
+        funcPermissions: funcConfig.permissions,
+        allServices,
+        data,
+        session,
+    });
+    // Combine all middleware: wiring tags → wiring middleware → func middleware → func tags
+    const allMiddleware = combineMiddleware({
+        wiringTags: tags,
+        wiringMiddleware,
+        funcMiddleware: funcConfig.middleware,
+        funcTags: funcConfig.tags,
+    });
+    if (allMiddleware.length > 0) {
         return (await runMiddleware(allServices, {
             http: allServices.http,
             mcp: allServices.mcp,
             rpc: allServices.rpc,
-        }, [...(transportMiddleware || []), ...(funcConfig.middleware || [])], async () => await funcConfig.func(allServices, data, session)));
+        }, allMiddleware, async () => await funcConfig.func(allServices, data, session)));
     }
     return (await funcConfig.func(allServices, data, session));
 };

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

@@ -35,12 +35,13 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  */
 export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
 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>> = {
+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;
     expose?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
-    middleware?: CorePikkuMiddleware[];
+    middleware?: PikkuMiddleware[];
+    tags?: string[];
     docs?: PikkuDocs;
 };

package/dist/index.d.ts

@@ -21,7 +21,8 @@ export * from './middleware/index.js';
 export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
-export { runMiddleware } from './middleware-runner.js';
+export { runMiddleware, addMiddleware, combineMiddleware, } from './middleware-runner.js';
+export { addPermission, getPermissionsForTags, runPermissions, } 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

@@ -21,7 +21,8 @@ export * from './middleware/index.js';
 export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
-export { runMiddleware } from './middleware-runner.js';
+export { runMiddleware, addMiddleware, combineMiddleware, } from './middleware-runner.js';
+export { addPermission, getPermissionsForTags, runPermissions, } 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

@@ -20,3 +20,73 @@ 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>;
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @template PikkuMiddleware The middleware type.
+ * @param {string} tag - The tag that the middleware should apply to.
+ * @param {PikkuMiddleware[]} middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws {Error} If middleware for the tag already exists.
+ *
+ * @example
+ * ```typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * ```
+ */
+export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(tag: string, middleware: PikkuMiddleware[]) => void;
+/**
+ * Retrieves middleware for a given set of tags.
+ *
+ * This function looks up all middleware registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Array of middleware functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all middleware for tags 'api' and 'auth'
+ * const middleware = getMiddlewareForTags(['api', 'auth'])
+ * ```
+ */
+export declare const getMiddlewareForTags: (tags?: string[]) => CorePikkuMiddleware[];
+/**
+ * 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 and function-level middleware, avoiding the need for manual spreading.
+ *
+ * @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
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
+ * ```
+ */
+export declare const combineMiddleware: ({ wiringMiddleware, wiringTags, funcMiddleware, funcTags, }?: {
+    wiringMiddleware?: CorePikkuMiddleware[];
+    wiringTags?: string[];
+    funcMiddleware?: CorePikkuMiddleware[];
+    funcTags?: string[];
+}) => CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -1,3 +1,4 @@
+import { pikkuState } from './pikku-state.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -16,10 +17,12 @@
  * );
  */
 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 (middlewares && index < middlewares.length) {
-            return await middlewares[index](services, interaction, () => dispatch(index + 1));
+        if (uniqueMiddleware && index < uniqueMiddleware.length) {
+            return await uniqueMiddleware[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -28,3 +31,103 @@ export const runMiddleware = async (services, interaction, middlewares, main) =>
     await dispatch(0);
     return result;
 };
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @template PikkuMiddleware The middleware type.
+ * @param {string} tag - The tag that the middleware should apply to.
+ * @param {PikkuMiddleware[]} middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws {Error} If middleware for the tag already exists.
+ *
+ * @example
+ * ```typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * ```
+ */
+export const addMiddleware = (tag, middleware) => {
+    const middlewareStore = pikkuState('misc', 'middleware');
+    // Check if tag already exists
+    if (middlewareStore[tag]) {
+        throw new Error(`Middleware for tag '${tag}' already exists. Use a different tag or remove the existing middleware first.`);
+    }
+    middlewareStore[tag] = middleware;
+};
+/**
+ * Retrieves middleware for a given set of tags.
+ *
+ * This function looks up all middleware registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Array of middleware functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all middleware for tags 'api' and 'auth'
+ * const middleware = getMiddlewareForTags(['api', 'auth'])
+ * ```
+ */
+export const getMiddlewareForTags = (tags) => {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    const middlewareStore = pikkuState('misc', 'middleware');
+    const applicableMiddleware = [];
+    // Collect middleware for all matching tags
+    for (const tag of tags) {
+        const tagMiddleware = middlewareStore[tag];
+        if (tagMiddleware) {
+            applicableMiddleware.push(...tagMiddleware);
+        }
+    }
+    return applicableMiddleware;
+};
+/**
+ * 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 and function-level middleware, avoiding the need for manual spreading.
+ *
+ * @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
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
+ * ```
+ */
+export const combineMiddleware = ({ wiringMiddleware, wiringTags, funcMiddleware, funcTags, } = {}) => {
+    // Run middleware in specific order:
+    // 1) wiringTags middleware
+    // 2) wiringMiddleware
+    // 3) funcMiddleware
+    // 4) funcTags middleware
+    const wiringTaggedMiddleware = getMiddlewareForTags(wiringTags);
+    const funcTaggedMiddleware = getMiddlewareForTags(funcTags);
+    return [
+        ...wiringTaggedMiddleware,
+        ...(wiringMiddleware || []),
+        ...(funcMiddleware || []),
+        ...funcTaggedMiddleware,
+    ];
+};

package/dist/permissions.d.ts

@@ -1,5 +1,5 @@
 import { CoreServices, CoreUserSession } from './types/core.types.js';
-import { CorePermissionGroup } from './function/functions.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.
  * @param services - The core services required for permission validation.
@@ -8,3 +8,59 @@ import { CorePermissionGroup } from './function/functions.types.js';
  * @returns A promise that resolves to void.
  */
 export declare const verifyPermissions: (permissions: CorePermissionGroup, services: CoreServices, data: any, session?: CoreUserSession) => Promise<boolean>;
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param {string} tag - The tag that the permissions should apply to.
+ * @param {any[]} permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws {Error} If permissions for the tag already exist.
+ *
+ * @example
+ * ```typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * ```
+ */
+export declare const addPermission: (tag: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => void;
+/**
+ * Retrieves permissions for a given set of tags.
+ *
+ * This function looks up all permissions registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up permissions for.
+ * @returns {any[]} Array of permission functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all permissions for tags 'api' and 'auth'
+ * const permissions = getPermissionsForTags(['api', 'auth'])
+ * ```
+ */
+export declare const getPermissionsForTags: (tags?: string[]) => Array<CorePermissionGroup | CorePikkuPermission>;
+/**
+ * Runs permission checks in the specified order:
+ * 1) wiring tag permissions - at least one must pass if any exist
+ * 2) wiring permissions - must pass if defined
+ * 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, }: {
+    wiringTags?: string[];
+    wiringPermissions?: CorePermissionGroup;
+    funcTags?: string[];
+    funcPermissions?: CorePermissionGroup;
+    allServices: CoreServices;
+    data: any;
+    session?: CoreUserSession;
+}) => Promise<void>;

package/dist/permissions.js

@@ -1,3 +1,5 @@
+import { pikkuState } from './pikku-state.js';
+import { ForbiddenError } from './errors/errors.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.
  * @param services - The core services required for permission validation.
@@ -30,3 +32,123 @@ export const verifyPermissions = async (permissions, services, data, session) =>
     }
     return false;
 };
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param {string} tag - The tag that the permissions should apply to.
+ * @param {any[]} permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws {Error} If permissions for the tag already exist.
+ *
+ * @example
+ * ```typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * ```
+ */
+export const addPermission = (tag, permissions) => {
+    const permissionsStore = pikkuState('misc', 'permissions');
+    // Check if tag already exists
+    if (permissionsStore[tag]) {
+        throw new Error(`Permissions for tag '${tag}' already exist. Use a different tag or remove the existing permissions first.`);
+    }
+    permissionsStore[tag] = permissions;
+};
+/**
+ * Retrieves permissions for a given set of tags.
+ *
+ * This function looks up all permissions registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up permissions for.
+ * @returns {any[]} Array of permission functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all permissions for tags 'api' and 'auth'
+ * const permissions = getPermissionsForTags(['api', 'auth'])
+ * ```
+ */
+export const getPermissionsForTags = (tags) => {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    const permissionsStore = pikkuState('misc', 'permissions');
+    const applicablePermissions = [];
+    // Collect permissions for all matching tags
+    for (const tag of new Set(tags)) {
+        const tagPermissions = permissionsStore[tag];
+        if (tagPermissions) {
+            if (Array.isArray(tagPermissions)) {
+                applicablePermissions.push(...tagPermissions);
+            }
+            else {
+                applicablePermissions.push(tagPermissions);
+            }
+        }
+    }
+    return applicablePermissions;
+};
+/**
+ * Runs permission checks in the specified order:
+ * 1) wiring tag permissions - at least one must pass if any exist
+ * 2) wiring permissions - must pass if defined
+ * 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, }) => {
+    let permissioned = true;
+    // 1. Wiring tag permissions - at least one must pass if any exist
+    const wiringTaggedPermissions = getPermissionsForTags(wiringTags || []);
+    if (wiringTaggedPermissions.length > 0) {
+        permissioned = false; // Start false, need at least one to pass
+        for (const permissions of wiringTaggedPermissions) {
+            const result = await verifyPermissions(typeof permissions === 'function' ? { permissions } : permissions, allServices, data, session);
+            if (result) {
+                permissioned = true;
+                break; // At least one passed, we're good at this level
+            }
+        }
+        if (!permissioned) {
+            throw new ForbiddenError('Permission denied - wiring tag permissions');
+        }
+    }
+    // 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');
+        }
+    }
+    // 3. Function tag permissions - at least one must pass if any exist
+    const funcTaggedPermissions = getPermissionsForTags(funcTags || []);
+    if (funcTaggedPermissions.length > 0) {
+        permissioned = false; // Start false, need at least one to pass
+        for (const permissions of funcTaggedPermissions) {
+            const result = await verifyPermissions(typeof permissions === 'function' ? { permissions } : permissions, allServices, data, session);
+            if (result) {
+                permissioned = true;
+                break; // At least one passed, we're good at this level
+            }
+        }
+        if (!permissioned) {
+            throw new ForbiddenError('Permission denied - function tag permissions');
+        }
+    }
+    // 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');
+        }
+    }
+};

package/dist/pikku-state.d.ts

@@ -3,7 +3,7 @@ import { CoreHTTPFunctionWiring, HTTPMethod, HTTPWiringsMeta } from './wirings/h
 import { FunctionsMeta, CorePikkuMiddleware } from './types/core.types.js';
 import { CoreScheduledTask, 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 } from './wirings/queue/queue.types.js';
 import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 interface PikkuState {
@@ -49,6 +49,8 @@ interface PikkuState {
     misc: {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;
+        middleware: Record<string, CorePikkuMiddleware[]>;
+        permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
     };
 }
 export declare const resetPikkuState: () => void;

package/dist/pikku-state.js

@@ -35,7 +35,9 @@ export const resetPikkuState = () => {
         },
         misc: {
             errors: globalThis.pikkuState?.misc?.errors || new Map(),
-            schemas: globalThis.pikkuState?.misc?.schema || new Map(),
+            schemas: new Map(),
+            middleware: {},
+            permissions: {},
         },
     };
 };

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

@@ -6,6 +6,8 @@ import { UserSessionService } from '../services/user-session-service.js';
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
 import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
+import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
+import { PikkuQueue } from '../wirings/queue/queue.types.js';
 export declare enum PikkuWiringTypes {
     http = "http",
     scheduler = "scheduler",
@@ -90,11 +92,14 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of interaction within Pikku and the outside world.
  */
-export interface PikkuInteraction {
-    http?: PikkuHTTP;
-    mcp?: PikkuMCP;
-    rpc?: PikkuRPC;
-}
+export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
+    http: PikkuHTTP<In>;
+    mcp: PikkuMCP;
+    rpc: PikkuRPC;
+    channel: PikkuChannel<unknown, Out>;
+    scheduledTask: PikkuScheduledTask;
+    queue: PikkuQueue;
+}>;
 /**
  * A function that can wrap an interaction and be called before or after
  */

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

@@ -56,6 +56,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             session,
             permissions,
             middleware,
+            tags: channelConfig.tags,
         });
     };
     const onMessage = async (rawData) => {