@pikku/core 0.9.2 → 0.9.4

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 { runMiddleware } from '../../middleware-runner.js';
+import { addMiddlewareForTags, 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';
@@ -64,9 +64,7 @@ export const wireHTTP = (httpWiring) => {
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
-    addFunction(routeMeta.pikkuFuncName, {
-        func: httpWiring.func,
-    });
+    addFunction(routeMeta.pikkuFuncName, httpWiring.func);
     const routes = pikkuState('http', 'routes');
     if (!routes.has(httpWiring.method)) {
         routes.set(httpWiring.method, new Map());
@@ -145,7 +143,16 @@ export const createHTTPInteraction = (request, response) => {
 /**
  * Validates the input data and executes the route handler with associated middleware.
  *
- * This function is the central execution point for a route. It performs these steps:
+ * NOTE: HTTP wiring handles middleware differently from other wirings (RPC, MCP, Queue, etc.)
+ * because HTTP needs to:
+ * 1. Check session early for performance (before expensive body parsing)
+ * 2. Handle HTTP-specific concerns (headers, cookies, SSE setup)
+ * 3. Process middleware that may set up authentication/session state
+ *
+ * Other wirings (RPC/MCP/Queue/Scheduler) simply pass middleware/permissions/auth
+ * directly to runPikkuFunc without processing them.
+ *
+ * This function performs these steps:
  *  1. Sets URL parameters on the request.
  *  2. Validates the user session if required.
  *  3. Creates session-specific services.
@@ -230,6 +237,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             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) {
@@ -243,7 +251,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         // http?.response?.end()
     };
     // Execute middleware, then run the main logic
-    await runMiddleware({ ...singletonServices, userSession }, { http }, middleware, runMain);
+    await runMiddleware({ ...singletonServices, userSession }, { http }, addMiddlewareForTags(middleware, route.tags), runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**

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

@@ -35,6 +35,7 @@ export type CoreHTTPFunction = {
     eventChannel?: false;
     returnsJSON?: false;
     timeout?: number;
+    tags?: string[];
     docs?: Partial<{
         description: string;
         response: string;

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

@@ -4,6 +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';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -19,9 +20,7 @@ export const wireMCPResource = (mcpResource) => {
     if (!mcpResourceMeta) {
         throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
     }
-    addFunction(mcpResourceMeta.pikkuFuncName, {
-        func: mcpResource.func,
-    });
+    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
     const resources = pikkuState('mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
@@ -34,9 +33,7 @@ export const wireMCPTool = (mcpTool) => {
     if (!mcpToolMeta) {
         throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`);
     }
-    addFunction(mcpToolMeta.pikkuFuncName, {
-        func: mcpTool.func,
-    });
+    addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func);
     const tools = pikkuState('mcp', 'tools');
     if (tools.has(mcpTool.name)) {
         throw new Error(`MCP tool already exists: ${mcpTool.name}`);
@@ -49,9 +46,7 @@ export const wireMCPPrompt = (mcpPrompt) => {
     if (!mcpPromptMeta) {
         throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`);
     }
-    addFunction(mcpPromptMeta.pikkuFuncName, {
-        func: mcpPrompt.func,
-    });
+    addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func);
     const prompts = pikkuState('mcp', 'prompts');
     if (prompts.has(mcpPrompt.name)) {
         throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`);
@@ -119,26 +114,33 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { sessio
             throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
         }
         singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
-        const getAllServices = async () => {
-            if (createSessionServices) {
-                const services = await createSessionServices(singletonServices, { mcp: interaction }, session);
-                sessionServices = services;
+        let result;
+        // Main MCP execution logic wrapped for middleware handling
+        const runMain = async () => {
+            const getAllServices = async () => {
+                if (createSessionServices) {
+                    const services = await createSessionServices(singletonServices, { mcp: interaction }, session);
+                    sessionServices = services;
+                    return rpcService.injectRPCService({
+                        ...singletonServices,
+                        ...services,
+                        mcp: interaction,
+                    });
+                }
                 return rpcService.injectRPCService({
                     ...singletonServices,
-                    ...services,
                     mcp: interaction,
                 });
-            }
-            return rpcService.injectRPCService({
-                ...singletonServices,
-                mcp: interaction,
+            };
+            result = await runPikkuFunc(pikkuFuncName, {
+                getAllServices,
+                session,
+                data: request.params,
+                tags: mcp.tags,
             });
         };
-        const result = await runPikkuFunc(pikkuFuncName, {
-            getAllServices,
-            session,
-            data: request.params,
-        });
+        // Get middleware for tags and run middleware
+        await runMiddleware(singletonServices, { mcp: interaction }, addMiddlewareForTags(mcp.middleware, mcp.tags), runMain);
         return {
             id: request.id,
             result,

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

@@ -1,4 +1,5 @@
 import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import { CorePikkuMiddleware } from '../../types/core.types.js';
 export type PikkuMCP<Tools extends string = any> = {
     uri?: string;
     sendResourceUpdated: (uri: string) => void;
@@ -38,7 +39,7 @@ export type MCPPromptMeta = Record<string, Omit<CoreMCPPrompt, 'func'> & {
 /**
  * Represents an MCP resource with specific properties.
  */
-export type CoreMCPResource<PikkuFunction = CorePikkuFunctionSessionless<any, any>> = {
+export type CoreMCPResource<PikkuFunction = CorePikkuFunctionSessionless<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     uri: string;
     title: string;
     description?: string;
@@ -47,11 +48,12 @@ export type CoreMCPResource<PikkuFunction = CorePikkuFunctionSessionless<any, an
     streaming?: boolean;
     func: PikkuFunction;
     tags?: string[];
+    middleware?: PikkuMiddleware[];
 };
 /**
  * Represents an MCP tool with specific properties.
  */
-export type CoreMCPTool<PikkuFunction = CorePikkuFunctionSessionless<any, any>> = {
+export type CoreMCPTool<PikkuFunction = CorePikkuFunctionSessionless<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     title?: string;
     description: string;
@@ -59,15 +61,17 @@ export type CoreMCPTool<PikkuFunction = CorePikkuFunctionSessionless<any, any>>
     func: PikkuFunction;
     tags?: string[];
     streaming?: boolean;
+    middleware?: PikkuMiddleware[];
 };
 /**
  * Represents an MCP prompt with specific properties.
  */
-export type CoreMCPPrompt<PikkuFunction = CorePikkuFunctionSessionless<any, MCPPromptResponse>> = {
+export type CoreMCPPrompt<PikkuFunction = CorePikkuFunctionSessionless<any, MCPPromptResponse>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     description?: string;
     func: PikkuFunction;
     tags?: string[];
+    middleware?: PikkuMiddleware[];
 };
 export type JsonRpcRequest = {
     jsonrpc: string;

package/dist/wirings/queue/index.d.ts

@@ -1,5 +1,5 @@
 export type * from './queue.types.js';
-export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, } from './queue-runner.js';
+export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
 export { validateWorkerConfig } from './validate-worker-config.js';
 export type { QueueConfigMapping } from './validate-worker-config.js';
 export { registerQueueWorkers } from './register-queue-helper.js';

package/dist/wirings/queue/index.js

@@ -1,5 +1,5 @@
 // Queue processor management
-export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, } from './queue-runner.js';
+export { wireQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, QueueJobDiscardedError, QueueJobFailedError, } from './queue-runner.js';
 // Configuration validation
 export { validateWorkerConfig } from './validate-worker-config.js';
 // Queue registration helper

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

@@ -1,7 +1,20 @@
 import type { CoreServices } from '../../types/core.types.js';
 import type { CoreQueueWorker, QueueJob } from './queue.types.js';
 import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import { PikkuError } from '../../errors/error-handler.js';
 import { CreateSessionServices } from '../../types/core.types.js';
+/**
+ * Error class for when a queue job is explicitly failed
+ */
+export declare class QueueJobFailedError extends PikkuError {
+    constructor(jobId: string, reason?: string);
+}
+/**
+ * Error class for when a queue job is explicitly discarded
+ */
+export declare class QueueJobDiscardedError extends PikkuError {
+    constructor(jobId: string, reason?: string);
+}
 /**
  * Add a queue processor to the system
  */
@@ -17,8 +30,9 @@ export declare function removeQueueWorker(name: string): Promise<void>;
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export declare function runQueueJob({ singletonServices, createSessionServices, job, }: {
+export declare function runQueueJob({ singletonServices, createSessionServices, job, updateProgress, }: {
     singletonServices: CoreServices;
     createSessionServices?: CreateSessionServices;
     job: QueueJob;
+    updateProgress?: (progress: number | string | object) => Promise<void>;
 }): Promise<void>;

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

@@ -1,14 +1,33 @@
-import { getErrorResponse } from '../../errors/error-handler.js';
+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';
 /**
  * Error class for queue processor not found
  */
-class QueueWorkerNotFoundError extends Error {
+class QueueWorkerNotFoundError extends PikkuError {
     constructor(name) {
         super(`Queue processor not found: ${name}`);
     }
 }
+/**
+ * Error class for when a queue job is explicitly failed
+ */
+export class QueueJobFailedError extends PikkuError {
+    constructor(jobId, reason) {
+        super(`Queue job ${jobId} failed${reason ? `: ${reason}` : ''}`);
+        this.name = 'QueueJobFailedError';
+    }
+}
+/**
+ * Error class for when a queue job is explicitly discarded
+ */
+export class QueueJobDiscardedError extends PikkuError {
+    constructor(jobId, reason) {
+        super(`Queue job ${jobId} discarded${reason ? `: ${reason}` : ''}`);
+        this.name = 'QueueJobDiscardedError';
+    }
+}
 /**
  * Add a queue processor to the system
  */
@@ -20,9 +39,7 @@ export const wireQueueWorker = (queueWorker) => {
         throw new Error(`Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`);
     }
     // Register the function with pikku
-    addFunction(processorMeta.pikkuFuncName, {
-        func: queueWorker.func,
-    });
+    addFunction(processorMeta.pikkuFuncName, queueWorker.func);
     // Store processor definition in state - runtime adapters will pick this up
     const registrations = pikkuState('queue', 'registrations');
     registrations.set(queueWorker.queueName, queueWorker);
@@ -47,28 +64,57 @@ export async function removeQueueWorker(name) {
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export async function runQueueJob({ singletonServices, createSessionServices, job, }) {
+export async function runQueueJob({ singletonServices, createSessionServices, job, updateProgress, }) {
     const logger = singletonServices.logger;
     const meta = pikkuState('queue', 'meta');
     const processorMeta = meta[job.queueName];
     if (!processorMeta) {
         throw new Error(`Processor metadata not found for: ${job.queueName}`);
     }
+    // Get the queue worker registration to access middleware
+    const registrations = pikkuState('queue', 'registrations');
+    const queueWorker = registrations.get(job.queueName);
+    if (!queueWorker) {
+        throw new Error(`Queue worker registration not found for: ${job.queueName}`);
+    }
+    // Create the queue interaction object
+    const queue = {
+        queueName: job.queueName,
+        jobId: job.id,
+        updateProgress: updateProgress ||
+            (async (progress) => {
+                logger.info(`Job ${job.id} progress: ${progress}`);
+                // Default implementation - just log the progress
+            }),
+        fail: async (reason) => {
+            throw new QueueJobFailedError(job.id, reason);
+        },
+        discard: async (reason) => {
+            throw new QueueJobDiscardedError(job.id, reason);
+        },
+    };
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
-        // Use provided singleton services
-        const getAllServices = () => ({
-            ...singletonServices,
-            ...(createSessionServices
-                ? createSessionServices(singletonServices, {}, undefined)
-                : {}),
-        });
-        // Execute the pikku function with the job data
-        const result = await runPikkuFunc(processorMeta.pikkuFuncName, {
-            getAllServices,
-            data: job.data,
-        });
-        logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
+        let result;
+        // Main job execution logic wrapped for middleware handling
+        const runMain = async () => {
+            // Use provided singleton services
+            const getAllServices = () => ({
+                ...singletonServices,
+                ...(createSessionServices
+                    ? createSessionServices(singletonServices, { queue }, undefined)
+                    : {}),
+            });
+            // Execute the pikku function with the job data
+            result = await runPikkuFunc(processorMeta.pikkuFuncName, {
+                getAllServices,
+                data: job.data,
+                tags: queueWorker.tags,
+            });
+            logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
+        };
+        // Get middleware for tags and combine with queue-specific middleware
+        await runMiddleware(singletonServices, { queue }, addMiddlewareForTags(queueWorker.middleware, queueWorker.tags), runMain);
         return result;
     }
     catch (error) {

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

@@ -1,4 +1,4 @@
-import { PikkuDocs } from '../../types/core.types.js';
+import { PikkuDocs, CorePikkuMiddleware } from '../../types/core.types.js';
 import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import { QueueConfigMapping } from './validate-worker-config.js';
 /**
@@ -144,11 +144,28 @@ export type queueWorkersMeta = Record<string, {
 /**
  * Core queue processor definition
  */
-export type CoreQueueWorker<PikkuFunction = CorePikkuFunctionSessionless<any, any>> = {
+export type CoreQueueWorker<PikkuFunction = CorePikkuFunctionSessionless<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     queueName: string;
     func: PikkuFunction;
     config?: PikkuWorkerConfig;
     docs?: PikkuDocs;
     session?: undefined;
     tags?: string[];
+    middleware?: PikkuMiddleware[];
 };
+/**
+ * Represents a queue interaction object for middleware
+ * Provides information and actions for the current queue job execution
+ */
+export interface PikkuQueue {
+    /** The name of the queue being processed */
+    queueName: string;
+    /** The current job ID */
+    jobId: string;
+    /** Update job progress (0-100 or custom value) */
+    updateProgress: (progress: number | string | object) => Promise<void>;
+    /** Fail the current job with optional reason */
+    fail: (reason?: string) => Promise<void>;
+    /** Discard/delete the job without retrying */
+    discard: (reason?: string) => Promise<void>;
+}

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

@@ -13,11 +13,14 @@ export declare class PikkuRPCService {
         };
         logger: import("../../index.js").Logger;
         variables: import("../../services/variables-service.js").VariablesService;
-        http?: import("../http/http.types.js").PikkuHTTP;
+        http?: import("../http/http.types.js").PikkuHTTP | undefined;
         mcp?: import("../mcp/mcp.types.js").PikkuMCP;
         rpc?: import("./rpc-types.js").PikkuRPC;
-        userSession?: import("../../index.js").UserSessionService<import("../../types/core.types.js").CoreUserSession> | undefined;
         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;
     };
 }
 export declare const rpcService: PikkuRPCService;

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

@@ -1,6 +1,7 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
-const getRPCMeta = (rpcName) => {
+import { ForbiddenError } from '../../errors/errors.js';
+const getPikkuFunctionName = (rpcName) => {
     const rpc = pikkuState('rpc', 'meta');
     const rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
@@ -16,11 +17,21 @@ class ContextAwareRPCService {
         this.services = services;
         this.options = options;
     }
+    async rpcExposed(funcName, data) {
+        const functionMeta = pikkuState('function', 'meta')[funcName];
+        if (!functionMeta) {
+            throw new Error(`Function not found: ${funcName}`);
+        }
+        if (!functionMeta.expose) {
+            throw new ForbiddenError();
+        }
+        return await this.rpc(funcName, data);
+    }
     async rpc(funcName, data) {
         const session = await this.services.userSession?.get();
         const rpcDepth = this.services.rpc?.depth || 0;
-        const rpcMeta = getRPCMeta(funcName);
-        return runPikkuFunc(rpcMeta.pikkuFuncName, {
+        const pikkuFuncName = getPikkuFunctionName(funcName);
+        return runPikkuFunc(pikkuFuncName, {
             getAllServices: () => {
                 this.services.rpc = this.services.rpc
                     ? {
@@ -56,6 +67,7 @@ export class PikkuRPCService {
             depth,
             global: false,
             invoke: serviceRPC.rpc.bind(serviceRPC),
+            invokeExposed: serviceRPC.rpc.bind(serviceRPC),
         };
         return serviceCopy;
     }

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

@@ -5,7 +5,7 @@ export type PikkuRPC<invoke extends Function = any> = {
 };
 export type RPCMeta = {
     pikkuFuncName: string;
-    exposed: boolean;
+    expose: boolean;
 };
 /**
  * Type for RPC handlers

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

@@ -1,55 +1,78 @@
-import { getErrorResponse } from '../../errors/error-handler.js';
+import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 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';
 export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
     if (!taskMeta) {
         throw new Error('Task metadata not found');
     }
-    addFunction(taskMeta.pikkuFuncName, {
-        func: scheduledTask.func,
-    });
+    addFunction(taskMeta.pikkuFuncName, scheduledTask.func);
     const tasks = pikkuState('scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);
     }
     tasks.set(scheduledTask.name, scheduledTask);
 };
-class ScheduledTaskNotFoundError extends Error {
+class ScheduledTaskNotFoundError extends PikkuError {
     constructor(title) {
         super(`Scheduled task not found: ${title}`);
     }
 }
+class ScheduledTaskSkippedError extends PikkuError {
+    constructor(taskName, reason) {
+        super(`Scheduled task '${taskName}' was skipped${reason ? `: ${reason}` : ''}`);
+        this.name = 'ScheduledTaskSkippedError';
+    }
+}
 export async function runScheduledTask({ name, session, singletonServices, createSessionServices, }) {
     let sessionServices;
+    const task = pikkuState('scheduler', 'tasks').get(name);
+    const meta = pikkuState('scheduler', 'meta')[name];
+    if (!task) {
+        throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`);
+    }
+    if (!meta) {
+        throw new ScheduledTaskNotFoundError(`Scheduled task meta not found: ${name}`);
+    }
+    // Create the scheduled task interaction object
+    const scheduledTask = {
+        name,
+        schedule: task.schedule,
+        executionTime: new Date(),
+        skip: (reason) => {
+            throw new ScheduledTaskSkippedError(name, reason);
+        },
+    };
     try {
-        const task = pikkuState('scheduler', 'tasks').get(name);
-        const meta = pikkuState('scheduler', 'meta')[name];
-        if (!task) {
-            throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`);
-        }
-        if (!meta) {
-            throw new ScheduledTaskNotFoundError(`Scheduled task meta not found: ${name}`);
-        }
         singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
-        const getAllServices = async () => {
-            if (createSessionServices) {
-                const sessionServices = await createSessionServices(singletonServices, {}, session);
-                return rpcService.injectRPCService({
-                    ...singletonServices,
-                    ...sessionServices,
-                });
-            }
-            return singletonServices;
+        let result;
+        // Main scheduled task execution logic wrapped for middleware handling
+        const runMain = async () => {
+            const getAllServices = async () => {
+                if (createSessionServices) {
+                    const services = await createSessionServices(singletonServices, { scheduledTask }, session);
+                    sessionServices = services;
+                    return rpcService.injectRPCService({
+                        ...singletonServices,
+                        ...services,
+                    });
+                }
+                return singletonServices;
+            };
+            result = await runPikkuFunc(meta.pikkuFuncName, {
+                getAllServices,
+                session,
+                data: undefined,
+                tags: task.tags,
+            });
         };
-        return await runPikkuFunc(meta.pikkuFuncName, {
-            getAllServices,
-            session,
-            data: undefined,
-        });
+        // Get middleware for tags and run middleware
+        await runMiddleware(singletonServices, { scheduledTask }, addMiddlewareForTags(task.middleware, task.tags), runMain);
+        return result;
     }
     catch (e) {
         const errorResponse = getErrorResponse(e);

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

@@ -1,4 +1,4 @@
-import { PikkuDocs, CoreUserSession } from '../../types/core.types.js';
+import { PikkuDocs, CoreUserSession, CorePikkuMiddleware } from '../../types/core.types.js';
 import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
@@ -14,10 +14,25 @@ export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> = Reco
 /**
  * Represents a core scheduled task.
  */
-export type CoreScheduledTask<PikkuFunction = CorePikkuFunctionSessionless<void, void>> = {
+export type CoreScheduledTask<PikkuFunction = CorePikkuFunctionSessionless<void, void>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     schedule: string;
     func: PikkuFunction;
     docs?: PikkuDocs;
     tags?: string[];
+    middleware?: PikkuMiddleware[];
 };
+/**
+ * Represents a scheduled task interaction object for middleware
+ * Provides information about the current scheduled task execution
+ */
+export interface PikkuScheduledTask {
+    /** The name of the scheduled task being executed */
+    name: string;
+    /** The cron schedule expression */
+    schedule: string;
+    /** Current execution timestamp */
+    executionTime: Date;
+    /** Skip the current task execution */
+    skip: (reason?: string) => void;
+}

package/package.json

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