@pikku/inspector 0.9.5 → 0.10.0

package/dist/add/add-middleware.js

@@ -0,0 +1,290 @@
+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';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.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 arg = args[0];
+        if (!arg)
+            return;
+        let actualHandler;
+        let name;
+        let description;
+        // Check if using object syntax: pikkuMiddleware({ func: ..., name: '...', description: '...' })
+        if (ts.isObjectLiteralExpression(arg)) {
+            // Extract name and description metadata
+            const nameValue = getPropertyValue(arg, 'name');
+            const descValue = getPropertyValue(arg, 'description');
+            name = typeof nameValue === 'string' ? nameValue : undefined;
+            description = typeof descValue === 'string' ? descValue : undefined;
+            // Extract the func property
+            const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
+            if (!fnProp ||
+                (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+                logger.error(`• pikkuMiddleware object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
+            logger.error(`• Handler for pikkuMiddleware is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(actualHandler);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.middleware.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            name,
+            description,
+        };
+        logger.debug(`• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
+        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
+        // If no wrapper is found, extract from the factory's returned function directly
+        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);
+            }
+        }
+        else {
+            // No pikkuMiddleware wrapper found - extract from factory's return value directly
+            // Factory pattern: (config) => (services, interaction, next) => { ... }
+            if (ts.isArrowFunction(factoryNode) ||
+                ts.isFunctionExpression(factoryNode)) {
+                const factoryBody = factoryNode.body;
+                // Check if the body is an arrow function (direct return)
+                if (ts.isArrowFunction(factoryBody) ||
+                    ts.isFunctionExpression(factoryBody)) {
+                    services = extractServicesFromFunction(factoryBody);
+                }
+            }
+        }
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        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, state.rootDir);
+        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, state.rootDir);
+            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, state.rootDir);
+        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, state.rootDir);
+            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,5 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
+ */
+export declare const addPermission: AddWiring;

package/dist/add/add-permission.js

@@ -0,0 +1,292 @@
+import * as ts from 'typescript';
+import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
+import { extractServicesFromFunction } from '../utils/extract-services.js';
+import { extractPermissionPikkuNames } from '../utils/permissions.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+/**
+ * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
+ */
+export const addPermission = (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 pikkuPermission(...) - individual permission function definition
+    if (expression.text === 'pikkuPermission') {
+        const arg = args[0];
+        if (!arg)
+            return;
+        let actualHandler;
+        let name;
+        let description;
+        // Check if using object syntax: pikkuPermission({ func: ..., name: '...', description: '...' })
+        if (ts.isObjectLiteralExpression(arg)) {
+            // Extract name and description metadata
+            const nameValue = getPropertyValue(arg, 'name');
+            const descValue = getPropertyValue(arg, 'description');
+            name = typeof nameValue === 'string' ? nameValue : undefined;
+            description = typeof descValue === 'string' ? descValue : undefined;
+            // Extract the func property
+            const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
+            if (!fnProp ||
+                (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+                logger.error(`• pikkuPermission object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
+            logger.error(`• Handler for pikkuPermission is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(actualHandler);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.permissions.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            name,
+            description,
+        };
+        logger.debug(`• Found permission with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
+        return;
+    }
+    // Handle pikkuPermissionFactory(...) - permission factory function
+    if (expression.text === 'pikkuPermissionFactory') {
+        const factoryNode = args[0];
+        if (!factoryNode)
+            return;
+        if (!ts.isArrowFunction(factoryNode) &&
+            !ts.isFunctionExpression(factoryNode)) {
+            logger.error(`• Handler for pikkuPermissionFactory is not a function.`);
+            return;
+        }
+        // Extract services by looking inside the factory function body
+        // The factory should return pikkuPermission(...), so we need to find that call
+        // If no wrapper is found, extract from the factory's returned function directly
+        let services = { optimized: false, services: [] };
+        const findPikkuPermissionCall = (node) => {
+            if (ts.isCallExpression(node)) {
+                const expr = node.expression;
+                if (ts.isIdentifier(expr) && expr.text === 'pikkuPermission') {
+                    return node;
+                }
+            }
+            return ts.forEachChild(node, findPikkuPermissionCall);
+        };
+        const pikkuPermissionCall = findPikkuPermissionCall(factoryNode);
+        if (pikkuPermissionCall && pikkuPermissionCall.arguments[0]) {
+            const permissionHandler = pikkuPermissionCall.arguments[0];
+            if (ts.isArrowFunction(permissionHandler) ||
+                ts.isFunctionExpression(permissionHandler)) {
+                services = extractServicesFromFunction(permissionHandler);
+            }
+        }
+        else {
+            // No pikkuPermission wrapper found - extract from factory's return value directly
+            // Factory pattern: (config) => (services, data, session) => { ... }
+            if (ts.isArrowFunction(factoryNode) ||
+                ts.isFunctionExpression(factoryNode)) {
+                const factoryBody = factoryNode.body;
+                // Check if the body is an arrow function (direct return)
+                if (ts.isArrowFunction(factoryBody) ||
+                    ts.isFunctionExpression(factoryBody)) {
+                    services = extractServicesFromFunction(factoryBody);
+                }
+            }
+        }
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.permissions.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            factory: true,
+        };
+        logger.debug(`• Found permission factory with services: ${services.services.join(', ')}`);
+        return;
+    }
+    // Handle addPermission('tag', [permission1, permission2])
+    // Supports two patterns:
+    // 1. export const x = () => addPermission('tag', [...])  (factory - tree-shakeable)
+    // 2. export const x = addPermission('tag', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addPermission') {
+        const tagArg = args[0];
+        const permissionsArrayArg = args[1];
+        if (!tagArg || !permissionsArrayArg)
+            return;
+        // Extract tag name
+        let tag;
+        if (ts.isStringLiteral(tagArg)) {
+            tag = tagArg.text;
+        }
+        if (!tag) {
+            logger.warn(`• addPermission call without valid tag string`);
+            return;
+        }
+        // Check if permissions is a literal array or object
+        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
+            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
+            logger.error(`• addPermission('${tag}', ...) must have a literal array or object as second argument`);
+            return;
+        }
+        // Extract permission pikkuFuncNames from array
+        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
+        if (permissionNames.length === 0) {
+            logger.warn(`• addPermission('${tag}', ...) has empty permissions array`);
+            return;
+        }
+        // Collect services from all permissions in the group
+        const allServices = new Set();
+        for (const permissionName of permissionNames) {
+            const permissionMeta = state.permissions.meta[permissionName];
+            if (permissionMeta && permissionMeta.services) {
+                for (const service of permissionMeta.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 = () => addPermission(...)
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addPermission(...)
+        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 apiTagPermissions = () => addPermission(...)
+                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, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addPermission('${tag}', [...])`);
+        }
+        // Store group metadata
+        state.permissions.tagPermissions.set(tag, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            permissionCount: permissionNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found tag permission group: ${tag} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+    // Handle addHTTPPermission(pattern, [permission1, permission2])
+    // Supports two patterns:
+    // 1. export const x = () => addHTTPPermission('*', [...])  (factory - tree-shakeable)
+    // 2. export const x = addHTTPPermission('*', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addHTTPPermission') {
+        const patternArg = args[0];
+        const permissionsArrayArg = args[1];
+        if (!patternArg || !permissionsArrayArg)
+            return;
+        // Extract route pattern
+        let pattern;
+        if (ts.isStringLiteral(patternArg)) {
+            pattern = patternArg.text;
+        }
+        if (!pattern) {
+            logger.warn(`• addHTTPPermission call without valid pattern string`);
+            return;
+        }
+        // Check if permissions is a literal array or object
+        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
+            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
+            logger.error(`• addHTTPPermission('${pattern}', ...) must have a literal array or object as second argument`);
+            return;
+        }
+        // Extract permission pikkuFuncNames from array
+        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
+        if (permissionNames.length === 0) {
+            logger.warn(`• addHTTPPermission('${pattern}', ...) has empty permissions array`);
+            return;
+        }
+        // Collect services from all permissions in the group
+        const allServices = new Set();
+        for (const permissionName of permissionNames) {
+            const permissionMeta = state.permissions.meta[permissionName];
+            if (permissionMeta && permissionMeta.services) {
+                for (const service of permissionMeta.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: () => addHTTPPermission(...)
+        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 apiRoutePermissions = () => addHTTPPermission(...)
+                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, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• HTTP permission group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addHTTPPermission('${pattern}', [...])`);
+        }
+        // Store group metadata
+        state.http.routePermissions.set(pattern, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            permissionCount: permissionNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found HTTP route permission group: ${pattern} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+};

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/add-queue-worker.js

@@ -0,0 +1,52 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
+export const addQueueWorker = (logger, node, checker, state, options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to addQueueWorker
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireQueueWorker') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const queueName = getPropertyValue(obj, 'queueName');
+        const docs = getPropertyValue(obj, 'docs') || undefined;
+        const tags = getPropertyTags(obj, 'Queue worker', queueName, logger);
+        // --- find the referenced function ---
+        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+        if (!funcInitializer) {
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for queue processor '${queueName}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        if (!queueName) {
+            logger.critical(ErrorCode.MISSING_QUEUE_NAME, `No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
+            return;
+        }
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- track used functions/middleware for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        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;