@pikku/inspector 0.9.5 → 0.9.6-next.0

package/dist/{add-functions.js → add/add-functions.js}

@@ -1,6 +1,8 @@
 import * as ts from 'typescript';
-import { extractFunctionName, getPropertyAssignmentInitializer, } from './utils.js';
-import { getPropertyValue } from './get-property-value.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { resolveMiddleware } from '../utils/middleware.js';
 const isValidVariableName = (name) => {
     const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     return regex.test(name);
@@ -186,7 +188,7 @@ function unwrapPromise(checker, type) {
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export function addFunctions(node, checker, state, logger) {
+export const addFunctions = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args, typeArguments } = node;
@@ -209,12 +211,14 @@ export function addFunctions(node, checker, state, logger) {
     let tags;
     let expose;
     let docs;
+    let objectNode;
     // determine the actual handler expression:
     // either the `func` prop or the first argument directly
     let handlerNode = args[0];
     let isDirectFunction = true; // Default to direct function format
     if (ts.isObjectLiteralExpression(handlerNode)) {
         isDirectFunction = false; // This is object format with func property
+        objectNode = handlerNode;
         tags = getPropertyValue(handlerNode, 'tags') || undefined;
         expose = getPropertyValue(handlerNode, 'expose');
         docs = getPropertyValue(handlerNode, 'docs');
@@ -258,7 +262,7 @@ export function addFunctions(node, checker, state, logger) {
         .map((tn) => checker.getTypeFromTypeNode(tn))
         .map((t) => unwrapPromise(checker, t));
     // --- Input Extraction ---
-    let { names: inputNames } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
+    let { names: inputNames, types: inputTypes } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
     // if (inputTypes.length === 0) {
     //   logger.debug(
     //     `\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`
@@ -280,6 +284,10 @@ export function addFunctions(node, checker, state, logger) {
     if (inputNames.length > 1) {
         logger.warn('More than one input type detected, only the first one will be used as a schema.');
     }
+    // --- resolve middleware ---
+    const middleware = objectNode
+        ? resolveMiddleware(state, objectNode, tags, checker)
+        : undefined;
     state.functions.meta[pikkuFuncName] = {
         pikkuFuncName,
         name,
@@ -292,7 +300,19 @@ export function addFunctions(node, checker, state, logger) {
         tags: tags || undefined,
         docs: docs || undefined,
         isDirectFunction,
+        middleware,
     };
+    // Store the input type for later use
+    if (inputTypes.length > 0) {
+        state.typesLookup.set(pikkuFuncName, inputTypes);
+    }
+    // Store function file location for wiring generation
+    if (exportedName) {
+        state.functions.files.set(pikkuFuncName, {
+            path: node.getSourceFile().fileName,
+            exportedName,
+        });
+    }
     if (exportedName || explicitName) {
         if (!exportedName) {
             logger.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
@@ -316,4 +336,4 @@ export function addFunctions(node, checker, state, logger) {
             });
         }
     }
-}
+};

package/dist/{add-http-route.d.ts → add/add-http-route.d.ts}

@@ -1,5 +1,4 @@
-import * as ts from 'typescript';
-import { InspectorState, InspectorFilters, InspectorLogger } from './types.js';
+import { AddWiring } from '../types.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
  * query and params. Returns undefined (we only mutate metaTypes).
@@ -13,4 +12,4 @@ export declare const getInputTypes: (metaTypes: Map<string, {
  * Simplified wireHTTP: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export declare const addHTTPRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;
+export declare const addHTTPRoute: AddWiring;

package/dist/{add-http-route.js → add/add-http-route.js}

@@ -1,8 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
 import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { matchesFilters } from '../utils/filter-utils.js';
+import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
  * query and params. Returns undefined (we only mutate metaTypes).
@@ -23,7 +26,7 @@ export const getInputTypes = (metaTypes, methodType, inputType, queryValues, par
  * Simplified wireHTTP: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export const addHTTPRoute = (node, checker, state, filters, logger) => {
+export const addHTTPRoute = (logger, node, checker, state, options) => {
     // only look at calls
     if (!ts.isCallExpression(node))
         return;
@@ -46,7 +49,7 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
     const tags = getPropertyValue(obj, 'tags') || undefined;
     const query = getPropertyValue(obj, 'query') || [];
     const filePath = node.getSourceFile().fileName;
-    if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.http, name: route, filePath }, logger)) {
+    if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.http, name: route, filePath }, logger)) {
         return;
     }
     // --- find the referenced function ---
@@ -65,6 +68,8 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
     const input = fnMeta.inputs?.[0] || null;
     // --- compute inputTypes (body/query/params) ---
     const inputTypes = getInputTypes(state.http.metaInputTypes, method, input, query, params);
+    // --- resolve middleware ---
+    const middleware = resolveHTTPMiddlewareFromObject(state, route, obj, tags, checker);
     // --- record route ---
     state.http.files.add(node.getSourceFile().fileName);
     state.http.meta[method][route] = {
@@ -76,5 +81,6 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
         inputTypes,
         docs,
         tags,
+        middleware,
     };
 };

package/dist/add/add-mcp-prompt.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addMCPPrompt: AddWiring;

package/dist/{add-mcp-prompt.js → add/add-mcp-prompt.js}

@@ -1,8 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
 import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addMCPPrompt = (node, checker, state, filters, logger) => {
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { matchesFilters } from '../utils/filter-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+export const addMCPPrompt = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -36,7 +39,7 @@ export const addMCPPrompt = (node, checker, state, filters, logger) => {
             return;
         }
         const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
+        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
             return;
         }
         // lookup existing function metadata
@@ -47,6 +50,8 @@ export const addMCPPrompt = (node, checker, state, filters, logger) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.promptsMeta[nameValue] = {
             pikkuFuncName,
@@ -56,6 +61,7 @@ export const addMCPPrompt = (node, checker, state, filters, logger) => {
             inputSchema,
             outputSchema,
             arguments: [], // Will be populated by CLI during serialization
+            middleware,
         };
     }
 };

package/dist/add/add-mcp-resource.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addMCPResource: AddWiring;

package/dist/{add-mcp-resource.js → add/add-mcp-resource.js}

@@ -1,8 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
 import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addMCPResource = (node, checker, state, filters, logger) => {
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { matchesFilters } from '../utils/filter-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+export const addMCPResource = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -42,7 +45,7 @@ export const addMCPResource = (node, checker, state, filters, logger) => {
             return;
         }
         const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.mcp, name: uriValue, filePath }, logger)) {
+        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: uriValue, filePath }, logger)) {
             return;
         }
         // lookup existing function metadata
@@ -53,6 +56,8 @@ export const addMCPResource = (node, checker, state, filters, logger) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.resourcesMeta[uriValue] = {
             pikkuFuncName,
@@ -63,6 +68,7 @@ export const addMCPResource = (node, checker, state, filters, logger) => {
             tags,
             inputSchema,
             outputSchema,
+            middleware,
         };
     }
 };

package/dist/add/add-mcp-tool.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addMCPTool: AddWiring;

package/dist/{add-mcp-tool.js → add/add-mcp-tool.js}

@@ -1,8 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
 import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addMCPTool = (node, checker, state, filters, logger) => {
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { matchesFilters } from '../utils/filter-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+export const addMCPTool = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -38,7 +41,7 @@ export const addMCPTool = (node, checker, state, filters, logger) => {
             return;
         }
         const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
+        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
             return;
         }
         // lookup existing function metadata
@@ -49,6 +52,8 @@ export const addMCPTool = (node, checker, state, filters, logger) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.toolsMeta[nameValue] = {
             pikkuFuncName,
@@ -59,6 +64,7 @@ export const addMCPTool = (node, checker, state, filters, logger) => {
             tags,
             inputSchema,
             outputSchema,
+            middleware,
         };
     }
 };

package/dist/add/add-middleware.d.ts

@@ -0,0 +1,5 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
+ */
+export declare const addMiddleware: AddWiring;

package/dist/add/add-middleware.js

@@ -0,0 +1,251 @@
+import * as ts from 'typescript';
+import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
+import { extractServicesFromFunction } from '../utils/extract-services.js';
+import { extractMiddlewarePikkuNames } from '../utils/middleware.js';
+/**
+ * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
+ */
+export const addMiddleware = (logger, node, checker, state) => {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    // only handle specific function calls
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    // Handle pikkuMiddleware(...) - individual middleware function definition
+    if (expression.text === 'pikkuMiddleware') {
+        const handlerNode = args[0];
+        if (!handlerNode)
+            return;
+        if (!ts.isArrowFunction(handlerNode) &&
+            !ts.isFunctionExpression(handlerNode)) {
+            logger.error(`• Handler for pikkuMiddleware is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(handlerNode);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+        state.middleware.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+        };
+        logger.debug(`• Found middleware with services: ${services.services.join(', ')}`);
+        return;
+    }
+    // Handle pikkuMiddlewareFactory(...) - middleware factory function
+    if (expression.text === 'pikkuMiddlewareFactory') {
+        const factoryNode = args[0];
+        if (!factoryNode)
+            return;
+        if (!ts.isArrowFunction(factoryNode) &&
+            !ts.isFunctionExpression(factoryNode)) {
+            logger.error(`• Handler for pikkuMiddlewareFactory is not a function.`);
+            return;
+        }
+        // Extract services by looking inside the factory function body
+        // The factory should return pikkuMiddleware(...), so we need to find that call
+        let services = { optimized: false, services: [] };
+        const findPikkuMiddlewareCall = (node) => {
+            if (ts.isCallExpression(node)) {
+                const expr = node.expression;
+                if (ts.isIdentifier(expr) && expr.text === 'pikkuMiddleware') {
+                    return node;
+                }
+            }
+            return ts.forEachChild(node, findPikkuMiddlewareCall);
+        };
+        const pikkuMiddlewareCall = findPikkuMiddlewareCall(factoryNode);
+        if (pikkuMiddlewareCall && pikkuMiddlewareCall.arguments[0]) {
+            const middlewareHandler = pikkuMiddlewareCall.arguments[0];
+            if (ts.isArrowFunction(middlewareHandler) ||
+                ts.isFunctionExpression(middlewareHandler)) {
+                services = extractServicesFromFunction(middlewareHandler);
+            }
+        }
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+        state.middleware.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            factory: true,
+        };
+        logger.debug(`• Found middleware factory with services: ${services.services.join(', ')}`);
+        return;
+    }
+    // Handle addMiddleware('tag', [middleware1, middleware2])
+    // Supports two patterns:
+    // 1. export const x = () => addMiddleware('tag', [...])  (factory - tree-shakeable)
+    // 2. export const x = addMiddleware('tag', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addMiddleware') {
+        const tagArg = args[0];
+        const middlewareArrayArg = args[1];
+        if (!tagArg || !middlewareArrayArg)
+            return;
+        // Extract tag name
+        let tag;
+        if (ts.isStringLiteral(tagArg)) {
+            tag = tagArg.text;
+        }
+        if (!tag) {
+            logger.warn(`• addMiddleware call without valid tag string`);
+            return;
+        }
+        // Check if middleware array is a literal array
+        if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
+            logger.error(`• addMiddleware('${tag}', ...) must have a literal array as second argument`);
+            return;
+        }
+        // Extract middleware pikkuFuncNames from array
+        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker);
+        if (middlewareNames.length === 0) {
+            logger.warn(`• addMiddleware('${tag}', ...) has empty middleware array`);
+            return;
+        }
+        // Collect services from all middleware in the group
+        const allServices = new Set();
+        for (const middlewareName of middlewareNames) {
+            const middlewareMeta = state.middleware.meta[middlewareName];
+            if (middlewareMeta && middlewareMeta.services) {
+                for (const service of middlewareMeta.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        // Check if this call is wrapped in a factory function
+        // We need to walk up the tree to see if the parent is: const x = () => addMiddleware(...)
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addMiddleware(...)
+        if (parent && ts.isArrowFunction(parent)) {
+            // Check if arrow function has no parameters
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                // For factories, we need to check the arrow function's parent for the export name
+                // const apiTagMiddleware = () => addMiddleware(...)
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        // Check if it's exported
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // If not a factory, get export name from the call expression itself
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• Middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addMiddleware('${tag}', [...])`);
+        }
+        // Store group metadata
+        state.middleware.tagMiddleware.set(tag, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            middlewareCount: middlewareNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found tag middleware group: ${tag} -> [${middlewareNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+    // Handle addHTTPMiddleware(pattern, [middleware1, middleware2])
+    // Supports two patterns:
+    // 1. export const x = () => addHTTPMiddleware('*', [...])  (factory - tree-shakeable)
+    // 2. export const x = addHTTPMiddleware('*', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addHTTPMiddleware') {
+        const patternArg = args[0];
+        const middlewareArrayArg = args[1];
+        if (!patternArg || !middlewareArrayArg)
+            return;
+        // Extract route pattern
+        let pattern;
+        if (ts.isStringLiteral(patternArg)) {
+            pattern = patternArg.text;
+        }
+        if (!pattern) {
+            logger.warn(`• addHTTPMiddleware call without valid pattern string`);
+            return;
+        }
+        // Check if middleware array is a literal array
+        if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
+            logger.error(`• addHTTPMiddleware('${pattern}', ...) must have a literal array as second argument`);
+            return;
+        }
+        // Extract middleware pikkuFuncNames from array
+        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker);
+        if (middlewareNames.length === 0) {
+            logger.warn(`• addHTTPMiddleware('${pattern}', ...) has empty middleware array`);
+            return;
+        }
+        // Collect services from all middleware in the group
+        const allServices = new Set();
+        for (const middlewareName of middlewareNames) {
+            const middlewareMeta = state.middleware.meta[middlewareName];
+            if (middlewareMeta && middlewareMeta.services) {
+                for (const service of middlewareMeta.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        // Check if this call is wrapped in a factory function
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addHTTPMiddleware(...)
+        if (parent && ts.isArrowFunction(parent)) {
+            // Check if arrow function has no parameters
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                // For factories, we need to check the arrow function's parent for the export name
+                // const apiRouteMiddleware = () => addHTTPMiddleware(...)
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        // Check if it's exported
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // If not a factory, get export name from the call expression itself
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• HTTP middleware group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addHTTPMiddleware('${pattern}', [...])`);
+        }
+        // Store group metadata
+        state.http.routeMiddleware.set(pattern, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            middlewareCount: middlewareNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found HTTP route middleware group: ${pattern} -> [${middlewareNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+};

package/dist/add/add-permission.d.ts

@@ -0,0 +1,6 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspect pikkuPermission calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export declare const addPermission: AddWiring;

package/dist/{add-permission.js → add/add-permission.js}

@@ -1,10 +1,11 @@
 import * as ts from 'typescript';
-import { extractFunctionName, extractServicesFromFunction } from './utils.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractServicesFromFunction } from '../utils/extract-services.js';
 /**
  * Inspect pikkuPermission calls and extract first-arg destructuring
  * for tree shaking optimization.
  */
-export function addPermission(node, checker, state, logger) {
+export const addPermission = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
@@ -32,4 +33,4 @@ export function addPermission(node, checker, state, logger) {
         exportedName,
     };
     logger.debug(`• Found permission with services: ${services.services.join(', ')}`);
-}
+};

package/dist/add/add-queue-worker.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addQueueWorker: AddWiring;

package/dist/{add-queue-worker.js → add/add-queue-worker.js}

@@ -1,8 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
 import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addQueueWorker = (node, checker, state, filters, logger) => {
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { matchesFilters } from '../utils/filter-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+export const addQueueWorker = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -33,16 +36,19 @@ export const addQueueWorker = (node, checker, state, filters, logger) => {
             return;
         }
         const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.queue, name: queueName, filePath }, logger)) {
+        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.queue, name: queueName, filePath }, logger)) {
             console.info(`• Skipping queue processor '${pikkuFuncName}' for queue '${queueName}' due to filter mismatch.`);
             return;
         }
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
         state.queueWorkers.files.add(node.getSourceFile().fileName);
         state.queueWorkers.meta[queueName] = {
             pikkuFuncName,
             queueName,
             docs,
             tags,
+            middleware,
         };
     }
 };

package/dist/{add-rpc-invocations.d.ts → add/add-rpc-invocations.d.ts}

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { InspectorState, InspectorLogger } from './types.js';
+import { InspectorState, InspectorLogger } from '../types.js';
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked
  */

package/dist/add/add-schedule.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addSchedule: AddWiring;

package/dist/{add-schedule.js → add/add-schedule.js}

@@ -1,8 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
 import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addSchedule = (node, checker, state, filters, logger) => {
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { matchesFilters } from '../utils/filter-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+export const addSchedule = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -32,9 +35,11 @@ export const addSchedule = (node, checker, state, filters, logger) => {
             return;
         }
         const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.scheduler, name: nameValue, filePath }, logger)) {
+        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.scheduler, name: nameValue, filePath }, logger)) {
             return;
         }
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
         state.scheduledTasks.meta[nameValue] = {
             pikkuFuncName,
@@ -42,6 +47,7 @@ export const addSchedule = (node, checker, state, filters, logger) => {
             schedule: scheduleValue,
             docs,
             tags,
+            middleware,
         };
     }
 };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { inspect } from './inspector.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export type { TypesMap } from './types-map.js';
 export type * from './types.js';
 export type { InspectorState } from './types.js';
+export type { FilesAndMethods, FilesAndMethodsErrors, } from './utils/get-files-and-methods.js';