@pikku/core 0.9.4 → 0.9.5

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## 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

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

@@ -2,7 +2,7 @@ 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, tags, }: {
+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;

package/dist/function/function-runner.js

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '../errors/errors.js';
-import { runMiddleware } from '../middleware-runner.js';
-import { verifyPermissions, getPermissionsForTags } 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, tags = [], }) => {
+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,32 +38,29 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
             coerceTopLevelDataFromSchema(inputSchemaName, data);
         }
     }
-    let permissioned = true;
-    // Check tagged permissions first - ALL must pass
-    const taggedPermissions = getPermissionsForTags([
-        ...tags,
-        ...(funcConfig.tags || []),
-    ]);
-    if (taggedPermissions.length > 0) {
-        const taggedResults = await Promise.all(taggedPermissions.map((permission) => permission(allServices, data, session)));
-        permissioned = taggedResults.every((result) => result);
-    }
-    // Only check function permissions if tagged permissions passed
-    if (permissioned && 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/index.d.ts

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

@@ -62,23 +62,31 @@ export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware
  */
 export declare const getMiddlewareForTags: (tags?: string[]) => CorePikkuMiddleware[];
 /**
- * Combines tag-based middleware with wiring-specific middleware.
+ * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
  * This helper function gets middleware for tags and combines it with any
- * wiring-specific middleware, avoiding the need for manual spreading.
+ * wiring-specific middleware and function-level middleware, avoiding the need for manual spreading.
  *
- * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
- * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @param {object} options - Configuration object for combining middleware.
+ * @param {CorePikkuMiddleware[] | undefined} options.wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} options.wiringTags - Array of wiring-level tags to look up middleware for.
+ * @param {CorePikkuMiddleware[] | undefined} options.funcMiddleware - Function-level middleware.
+ * @param {string[] | undefined} options.funcTags - Array of function-level tags to look up middleware for.
  * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
  *
  * @example
  * ```typescript
- * // Instead of:
- * const taggedMiddleware = getMiddlewareForTags(tags)
- * const combined = [...taggedMiddleware, ...(middleware || [])]
- *
- * // Use:
- * const combined = addMiddlewareForTags(middleware, tags)
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
  * ```
  */
-export declare const addMiddlewareForTags: (wiringMiddleware?: CorePikkuMiddleware[], tags?: string[]) => CorePikkuMiddleware[];
+export declare const combineMiddleware: ({ wiringMiddleware, wiringTags, funcMiddleware, funcTags, }?: {
+    wiringMiddleware?: CorePikkuMiddleware[];
+    wiringTags?: string[];
+    funcMiddleware?: CorePikkuMiddleware[];
+    funcTags?: string[];
+}) => CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -94,26 +94,40 @@ export const getMiddlewareForTags = (tags) => {
     return applicableMiddleware;
 };
 /**
- * Combines tag-based middleware with wiring-specific middleware.
+ * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
  * This helper function gets middleware for tags and combines it with any
- * wiring-specific middleware, avoiding the need for manual spreading.
+ * wiring-specific middleware and function-level middleware, avoiding the need for manual spreading.
  *
- * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
- * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @param {object} options - Configuration object for combining middleware.
+ * @param {CorePikkuMiddleware[] | undefined} options.wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} options.wiringTags - Array of wiring-level tags to look up middleware for.
+ * @param {CorePikkuMiddleware[] | undefined} options.funcMiddleware - Function-level middleware.
+ * @param {string[] | undefined} options.funcTags - Array of function-level tags to look up middleware for.
  * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
  *
  * @example
  * ```typescript
- * // Instead of:
- * const taggedMiddleware = getMiddlewareForTags(tags)
- * const combined = [...taggedMiddleware, ...(middleware || [])]
- *
- * // Use:
- * const combined = addMiddlewareForTags(middleware, tags)
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
  * ```
  */
-export const addMiddlewareForTags = (wiringMiddleware, tags) => {
-    const taggedMiddleware = getMiddlewareForTags(tags);
-    return [...taggedMiddleware, ...(wiringMiddleware || [])];
+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.
@@ -31,7 +31,7 @@ export declare const verifyPermissions: (permissions: CorePermissionGroup, servi
  * addPermission('api', [readPermission])
  * ```
  */
-export declare const addPermission: (tag: string, permissions: any[]) => void;
+export declare const addPermission: (tag: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => void;
 /**
  * Retrieves permissions for a given set of tags.
  *
@@ -47,4 +47,20 @@ export declare const addPermission: (tag: string, permissions: any[]) => void;
  * const permissions = getPermissionsForTags(['api', 'auth'])
  * ```
  */
-export declare const getPermissionsForTags: (tags?: string[]) => any[];
+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,4 +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.
@@ -87,8 +88,67 @@ export const getPermissionsForTags = (tags) => {
     for (const tag of new Set(tags)) {
         const tagPermissions = permissionsStore[tag];
         if (tagPermissions) {
-            applicablePermissions.push(...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 {
@@ -50,7 +50,7 @@ interface PikkuState {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;
         middleware: Record<string, CorePikkuMiddleware[]>;
-        permissions: Record<string, any[]>;
+        permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
     };
 }
 export declare const resetPikkuState: () => void;

package/dist/pikku-state.js

@@ -35,9 +35,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: {},
         },
     };
 };

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

@@ -92,14 +92,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: any;
 }>;
 /**
  * A function that can wrap an interaction and be called before or after

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

@@ -4,7 +4,7 @@ import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.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 { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 import { rpcService } from '../../rpc/rpc-runner.js';
@@ -77,6 +77,9 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
+    }, { http }, combineMiddleware({
+        wiringMiddleware: channelConfig.middleware,
+        wiringTags: channelConfig.tags,
+    }), main);
     return channelHandler;
 };

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

@@ -4,7 +4,7 @@ import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.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 { runPikkuFuncDirectly } from '../../../function/function-runner.js';
@@ -76,7 +76,10 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
+    }, { http }, combineMiddleware({
+        wiringMiddleware: channelConfig.middleware,
+        wiringTags: channelConfig.tags,
+    }), main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;

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

@@ -2,7 +2,7 @@ import { match } from 'path-to-regexp';
 import { MissingSessionError, NotFoundError } from '../../errors/errors.js';
 import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
 import { PikkuUserSessionService, } 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';
@@ -250,8 +250,15 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         // TODO: Evaluate if the response stream should be explicitly ended.
         // 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), runMain);
+    await runMiddleware({ ...singletonServices, userSession }, { http }, combineMiddleware({
+        wiringMiddleware: middleware,
+        wiringTags: route.tags,
+        funcMiddleware: funcConfig?.middleware,
+        funcTags: funcConfig?.tags,
+    }), runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**

package/dist/wirings/http/http.types.d.ts

@@ -46,8 +46,8 @@ export type CoreHTTPFunction = {
 /**
  * Represents a http interaction within Pikku, including a request and response.
  */
-export interface PikkuHTTP {
-    request?: PikkuHTTPRequest;
+export interface PikkuHTTP<In = unknown> {
+    request?: PikkuHTTPRequest<In>;
     response?: PikkuHTTPResponse;
 }
 /**
@@ -169,12 +169,12 @@ export interface PikkuHTTPRequest<In = unknown> {
     setParams(params: Record<string, string | string[] | undefined>): void;
     query(): PikkuQuery;
 }
-export interface PikkuHTTPResponse {
+export interface PikkuHTTPResponse<Out = unknown> {
     status(code: number): this;
     cookie(name: string, value: string | null, options: SerializeOptions): this;
     header(name: string, value: string | string[]): this;
     arrayBuffer(data: ArrayBuffer | ArrayBufferView | Blob | string | FormData | URLSearchParams | ReadableStream): this;
-    json(data: unknown): this;
+    json(data: Out): this;
     redirect(location: string, status?: number): this;
     close?: () => void;
     setMode?: (mode: 'stream') => void;

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

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
 import { BadRequestError, NotFoundError } from '../../errors/errors.js';
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -139,8 +139,13 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { sessio
                 tags: mcp.tags,
             });
         };
-        // Get middleware for tags and run middleware
-        await runMiddleware(singletonServices, { mcp: interaction }, addMiddlewareForTags(mcp.middleware, mcp.tags), runMain);
+        const funcConfig = pikkuState('function', 'functions').get(pikkuFuncName);
+        await runMiddleware(singletonServices, { mcp: interaction }, combineMiddleware({
+            wiringMiddleware: mcp.middleware,
+            wiringTags: mcp.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.tags,
+        }), runMain);
         return {
             id: request.id,
             result,

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

@@ -1,7 +1,7 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 /**
  * Error class for queue processor not found
  */
@@ -113,8 +113,15 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
             });
             logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
         };
+        // Get function config for middleware and tags
+        const funcConfig = pikkuState('function', 'functions').get(processorMeta.pikkuFuncName);
         // Get middleware for tags and combine with queue-specific middleware
-        await runMiddleware(singletonServices, { queue }, addMiddlewareForTags(queueWorker.middleware, queueWorker.tags), runMain);
+        await runMiddleware(singletonServices, { queue }, combineMiddleware({
+            wiringMiddleware: queueWorker.middleware,
+            wiringTags: queueWorker.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.tags,
+        }), runMain);
         return result;
     }
     catch (error) {

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

@@ -13,13 +13,12 @@ export declare class PikkuRPCService {
         };
         logger: import("../../index.js").Logger;
         variables: import("../../services/variables-service.js").VariablesService;
-        http?: import("../http/http.types.js").PikkuHTTP | undefined;
+        http?: import("../http/http.types.js").PikkuHTTP<unknown> | undefined;
         mcp?: import("../mcp/mcp.types.js").PikkuMCP;
         rpc?: import("./rpc-types.js").PikkuRPC;
         channel?: import("../channel/channel.types.js").PikkuChannel<unknown, unknown>;
         scheduledTask?: import("../scheduler/scheduler.types.js").PikkuScheduledTask | undefined;
         queue?: import("../queue/queue.types.js").PikkuQueue | undefined;
-        s?: any;
         userSession?: import("../../index.js").UserSessionService<import("../../types/core.types.js").CoreUserSession> | undefined;
     };
 }

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

@@ -3,7 +3,7 @@ import { closeSessionServices } from '../../utils.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
@@ -70,8 +70,13 @@ export async function runScheduledTask({ name, session, singletonServices, creat
                 tags: task.tags,
             });
         };
-        // Get middleware for tags and run middleware
-        await runMiddleware(singletonServices, { scheduledTask }, addMiddlewareForTags(task.middleware, task.tags), runMain);
+        const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName);
+        await runMiddleware(singletonServices, { scheduledTask }, combineMiddleware({
+            wiringMiddleware: task.middleware,
+            wiringTags: task.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.tags,
+        }), runMain);
         return result;
     }
     catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",