@pikku/core 0.9.3 → 0.9.4

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

package/src/function/function-runner.ts

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '../errors/errors.js'
 import { runMiddleware } from '../middleware-runner.js'
-import { verifyPermissions } from '../permissions.js'
+import { verifyPermissions, getPermissionsForTags } from '../permissions.js'
 import { pikkuState } from '../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
 import {
@@ -50,6 +50,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
     permissions: transportPermissions,
     middleware: transportMiddleware,
     coerceDataFromSchema,
+    tags = [],
   }: {
     getAllServices: () => Promise<CoreServices> | CoreServices
     data: In
@@ -57,6 +58,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
     permissions?: CorePermissionGroup
     middleware?: CorePikkuMiddleware[]
     coerceDataFromSchema?: boolean
+    tags?: string[]
   }
 ): Promise<Out> => {
   const funcConfig = pikkuState('function', 'functions').get(funcName)
@@ -92,7 +94,23 @@ export const runPikkuFunc = async <In = any, Out = any>(
   }
 
   let permissioned = true
-  if (funcConfig.permissions) {
+
+  // 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,
@@ -100,6 +118,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
       session
     )
   }
+
   if (!permissioned && transportPermissions) {
     permissioned = await verifyPermissions(
       transportPermissions,

package/src/function/functions.types.ts

@@ -87,12 +87,14 @@ export type CorePikkuFunctionConfig<
     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/src/index.ts

@@ -21,7 +21,12 @@ 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,
+  addMiddlewareForTags,
+} from './middleware-runner.js'
+export { addPermission, getPermissionsForTags } 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/src/middleware-runner.ts

@@ -4,6 +4,7 @@ import {
   PikkuInteraction,
   CorePikkuMiddleware,
 } from './types/core.types.js'
+import { pikkuState } from './pikku-state.js'
 
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
@@ -30,10 +31,13 @@ export const runMiddleware = async <Middleware extends CorePikkuMiddleware>(
   middlewares: Middleware[],
   main?: () => Promise<unknown>
 ): Promise<unknown> => {
+  // Deduplicate middleware using Set to avoid running the same middleware multiple times
+  const uniqueMiddleware = Array.from(new Set(middlewares))
+
   let result: any
   const dispatch = async (index: number): Promise<any> => {
-    if (middlewares && index < middlewares.length) {
-      return await middlewares[index]!(services as any, interaction, () =>
+    if (uniqueMiddleware && index < uniqueMiddleware.length) {
+      return await uniqueMiddleware[index]!(services as any, interaction, () =>
         dispatch(index + 1)
       )
     } else if (main) {
@@ -43,3 +47,107 @@ export const runMiddleware = async <Middleware extends CorePikkuMiddleware>(
   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 = <PikkuMiddleware extends CorePikkuMiddleware>(
+  tag: string,
+  middleware: PikkuMiddleware[]
+) => {
+  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 as CorePikkuMiddleware[]
+}
+
+/**
+ * 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?: string[]
+): CorePikkuMiddleware[] => {
+  if (!tags || tags.length === 0) {
+    return []
+  }
+
+  const middlewareStore = pikkuState('misc', 'middleware')
+  const applicableMiddleware: CorePikkuMiddleware[] = []
+
+  // 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.
+ *
+ * This helper function gets middleware for tags and combines it with any
+ * wiring-specific 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.
+ * @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)
+ * ```
+ */
+export const addMiddlewareForTags = (
+  wiringMiddleware?: CorePikkuMiddleware[],
+  tags?: string[]
+): CorePikkuMiddleware[] => {
+  const taggedMiddleware = getMiddlewareForTags(tags)
+  return [...taggedMiddleware, ...(wiringMiddleware || [])]
+}