@pikku/core 0.9.3 → 0.9.5

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 { 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';
@@ -17,25 +17,33 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         http = createHTTPInteraction(request, response);
         route = http?.request?.path();
     }
+    let openingData, channelConfig, meta;
+    try {
+        ;
+        ({ openingData, channelConfig, meta } = await openChannel({
+            channelId,
+            createSessionServices,
+            respondWith404,
+            request,
+            response,
+            route,
+            singletonServices,
+            skipUserSession,
+            coerceDataFromSchema,
+            userSession,
+        }));
+    }
+    catch (e) {
+        handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        return;
+    }
     const main = async () => {
         try {
-            const { openingData, channelConfig, meta } = await openChannel({
-                channelId,
-                createSessionServices,
-                respondWith404,
-                request,
-                response,
-                route,
-                singletonServices,
-                skipUserSession,
-                coerceDataFromSchema,
-                userSession,
-            });
             channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
             const channel = channelHandler.getChannel();
             const session = await userSession.get();
             if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http }, session);
+                sessionServices = await createSessionServices(singletonServices, { http, channel }, session);
             }
             const allServices = rpcService.injectRPCService({
                 ...singletonServices,
@@ -69,6 +77,9 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, route.middleware || [], 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 { 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 }, channelConfig.middleware || [], 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 { 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';
@@ -143,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.
@@ -228,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) {
@@ -240,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 }, middleware, 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

@@ -35,6 +35,7 @@ export type CoreHTTPFunction = {
     eventChannel?: false;
     returnsJSON?: false;
     timeout?: number;
+    tags?: string[];
     docs?: Partial<{
         description: string;
         response: string;
@@ -45,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;
 }
 /**
@@ -168,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,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 { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -113,26 +114,38 @@ 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,
-        });
+        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/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 { combineMiddleware, 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
  */
@@ -45,28 +64,64 @@ 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 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 }, combineMiddleware({
+            wiringMiddleware: queueWorker.middleware,
+            wiringTags: queueWorker.tags,
+            funcMiddleware: funcConfig?.middleware,
+            funcTags: funcConfig?.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,13 @@ 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<unknown> | 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;
+        userSession?: import("../../index.js").UserSessionService<import("../../types/core.types.js").CoreUserSession> | undefined;
     };
 }
 export declare const rpcService: PikkuRPCService;

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

@@ -1,8 +1,9 @@
-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 { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
@@ -16,38 +17,67 @@ export const wireScheduler = (scheduledTask) => {
     }
     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,
-        });
+        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) {
         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.3",
+  "version": "0.9.5",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",