@pikku/inspector 0.11.1 → 0.12.0

package/dist/add/add-permission.js

@@ -1,9 +1,38 @@
 import * as ts from 'typescript';
-import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
-import { extractServicesFromFunction } from '../utils/extract-services.js';
+import { extractFunctionName, isNamedExport, makeContextBasedId, } from '../utils/extract-function-name.js';
+import { extractServicesFromFunction, extractUsedWires, } 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';
+function renameTempDefinitions(state, definitionIds, groupType, groupKey) {
+    const tempIndices = definitionIds
+        .map((name, i) => (name.startsWith('__temp_') ? i : -1))
+        .filter((i) => i >= 0);
+    for (const idx of tempIndices) {
+        const oldId = definitionIds[idx];
+        const newId = tempIndices.length === 1
+            ? makeContextBasedId(groupType, groupKey)
+            : makeContextBasedId(groupType, groupKey, String(idx));
+        const existing = state.permissions.definitions[oldId];
+        if (existing) {
+            delete state.permissions.definitions[oldId];
+            state.permissions.definitions[newId] = existing;
+        }
+        definitionIds[idx] = newId;
+    }
+}
+function isInsidePermissionFactory(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isCallExpression(current) &&
+            ts.isIdentifier(current.expression) &&
+            current.expression.text === 'pikkuPermissionFactory') {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 /**
  * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
  */
@@ -17,20 +46,20 @@ export const addPermission = (logger, node, checker, state) => {
     }
     // Handle pikkuPermission(...) - individual permission function definition
     if (expression.text === 'pikkuPermission') {
+        // Skip if nested inside pikkuPermissionFactory — the factory handler extracts services itself
+        if (isInsidePermissionFactory(node))
+            return;
         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))) {
@@ -47,16 +76,97 @@ export const addPermission = (logger, node, checker, state) => {
             return;
         }
         const services = extractServicesFromFunction(actualHandler);
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
-        state.permissions.meta[pikkuFuncName] = {
+        const wires = extractUsedWires(actualHandler, 2);
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuPermission() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myPermission = pikkuPermission(...)`);
+                return;
+            }
+        }
+        const dataParam = actualHandler.parameters[1];
+        const dataParamName = dataParam && ts.isIdentifier(dataParam.name) ? dataParam.name.text : null;
+        const requiresData = !(dataParamName && dataParamName.startsWith('_'));
+        state.permissions.definitions[pikkuFuncId] = {
+            services,
+            wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            name,
+            description,
+            ...(requiresData ? {} : { requiresData: false }),
+        };
+        logger.debug(`• Found permission with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}${!requiresData ? ' (auth-only)' : ''}`);
+        return;
+    }
+    if (expression.text === 'pikkuAuth') {
+        if (isInsidePermissionFactory(node))
+            return;
+        const arg = args[0];
+        if (!arg)
+            return;
+        let actualHandler;
+        let name;
+        let description;
+        if (ts.isObjectLiteralExpression(arg)) {
+            const nameValue = getPropertyValue(arg, 'name');
+            const descValue = getPropertyValue(arg, 'description');
+            name = typeof nameValue === 'string' ? nameValue : undefined;
+            description = typeof descValue === 'string' ? descValue : undefined;
+            const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
+            if (!fnProp ||
+                (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+                logger.error(`• pikkuAuth object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
+            logger.error(`• Handler for pikkuAuth is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(actualHandler);
+        const wires = extractUsedWires(actualHandler, 1);
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuAuth() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myAuth = pikkuAuth(...)`);
+                return;
+            }
+        }
+        state.permissions.definitions[pikkuFuncId] = {
             services,
+            wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
             exportedName,
             name,
             description,
+            requiresData: false,
         };
-        logger.debug(`• Found permission with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
+        logger.debug(`• Found auth permission with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
     // Handle pikkuPermissionFactory(...) - permission factory function
@@ -73,6 +183,10 @@ export const addPermission = (logger, node, checker, state) => {
         // 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: [] };
+        let wires = {
+            optimized: true,
+            wires: [],
+        };
         const findPikkuPermissionCall = (node) => {
             if (ts.isCallExpression(node)) {
                 const expr = node.expression;
@@ -88,24 +202,39 @@ export const addPermission = (logger, node, checker, state) => {
             if (ts.isArrowFunction(permissionHandler) ||
                 ts.isFunctionExpression(permissionHandler)) {
                 services = extractServicesFromFunction(permissionHandler);
+                wires = extractUsedWires(permissionHandler, 2);
             }
         }
         else {
-            // No pikkuPermission wrapper found - extract from factory's return value directly
-            // Factory pattern: (config) => (services, data, wire) => { ... }
             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);
+                    wires = extractUsedWires(factoryBody, 2);
                 }
             }
         }
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
-        state.permissions.meta[pikkuFuncName] = {
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuPermissionFactory() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myPermission = pikkuPermissionFactory(...)`);
+                return;
+            }
+        }
+        state.permissions.definitions[pikkuFuncId] = {
             services,
+            wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
             exportedName,
@@ -138,38 +267,31 @@ export const addPermission = (logger, node, checker, state) => {
             logger.error(`• addPermission('${tag}', ...) must have a literal array or object as second argument`);
             return;
         }
-        // Extract permission pikkuFuncNames from array
+        // Extract permission pikkuFuncIds 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
+        renameTempDefinitions(state, permissionNames, 'tag', tag);
         const allServices = new Set();
         for (const permissionName of permissionNames) {
-            const permissionMeta = state.permissions.meta[permissionName];
+            const permissionMeta = state.permissions.definitions[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;
                         }
@@ -177,17 +299,14 @@ export const addPermission = (logger, node, checker, state) => {
                 }
             }
         }
-        // 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,
@@ -196,7 +315,8 @@ export const addPermission = (logger, node, checker, state) => {
                 optimized: false,
                 services: Array.from(allServices),
             },
-            permissionCount: permissionNames.length,
+            count: permissionNames.length,
+            instanceIds: permissionNames,
             isFactory,
         });
         logger.debug(`• Found tag permission group: ${tag} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
@@ -226,37 +346,31 @@ export const addPermission = (logger, node, checker, state) => {
             logger.error(`• addHTTPPermission('${pattern}', ...) must have a literal array or object as second argument`);
             return;
         }
-        // Extract permission pikkuFuncNames from array
+        // Extract permission pikkuFuncIds 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
+        renameTempDefinitions(state, permissionNames, 'http', pattern);
         const allServices = new Set();
         for (const permissionName of permissionNames) {
-            const permissionMeta = state.permissions.meta[permissionName];
+            const permissionMeta = state.permissions.definitions[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;
                         }
@@ -264,17 +378,14 @@ export const addPermission = (logger, node, checker, state) => {
                 }
             }
         }
-        // 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,
@@ -283,7 +394,8 @@ export const addPermission = (logger, node, checker, state) => {
                 optimized: false,
                 services: Array.from(allServices),
             },
-            permissionCount: permissionNames.length,
+            count: permissionNames.length,
+            instanceIds: permissionNames,
             isFactory,
         });
         logger.debug(`• Found HTTP route permission group: ${pattern} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);

package/dist/add/add-queue-worker.js

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractFunctionName, makeContextBasedId, } 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';
@@ -21,28 +21,34 @@ export const addQueueWorker = (logger, node, checker, state) => {
     }
     if (ts.isObjectLiteralExpression(firstArg)) {
         const obj = firstArg;
-        const queueName = getPropertyValue(obj, 'queueName');
-        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Queue worker', queueName, logger);
+        const name = getPropertyValue(obj, 'name');
+        const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'Queue worker', name, logger);
+        if (disabled)
+            return;
         // --- 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}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for queue processor '${name}'.`);
             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}'.`);
+        const extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+        let pikkuFuncId = extracted.pikkuFuncId;
+        if (pikkuFuncId.startsWith('__temp_') && name) {
+            pikkuFuncId = makeContextBasedId('queue', name);
+        }
+        if (!name) {
+            logger.critical(ErrorCode.MISSING_QUEUE_NAME, `No 'name' provided for queue processor function '${pikkuFuncId}'.`);
             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.serviceAggregation.usedFunctions.add(pikkuFuncId);
+        extractWireNames(middleware).forEach((n) => state.serviceAggregation.usedMiddleware.add(n));
         state.queueWorkers.files.add(node.getSourceFile().fileName);
-        state.queueWorkers.meta[queueName] = {
-            pikkuFuncName,
-            queueName,
+        state.queueWorkers.meta[name] = {
+            pikkuFuncId,
+            name,
             summary,
             description,
             errors,

package/dist/add/add-rpc-invocations.d.ts

@@ -2,5 +2,8 @@ import * as ts from 'typescript';
 import { InspectorState, InspectorLogger } from '../types.js';
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ * Also detects external package usage via:
+ * - Namespaced calls: rpc.invoke('namespace:function')
+ * - External helper: external('namespace:function')
  */
 export declare function addRPCInvocations(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-rpc-invocations.js

@@ -1,35 +1,75 @@
 import * as ts from 'typescript';
+/**
+ * Helper to extract namespace from a namespaced function reference like 'ext:hello'
+ */
+function extractNamespace(functionRef) {
+    const colonIndex = functionRef.indexOf(':');
+    if (colonIndex !== -1) {
+        return functionRef.substring(0, colonIndex);
+    }
+    return null;
+}
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ * Also detects external package usage via:
+ * - Namespaced calls: rpc.invoke('namespace:function')
+ * - External helper: external('namespace:function')
  */
 export function addRPCInvocations(node, state, logger) {
-    // Look for property access expressions: rpc.invoke
-    if (ts.isPropertyAccessExpression(node)) {
-        const { expression, name } = node;
-        // Check if this is accessing 'invoke' property
-        if (name.text === 'invoke') {
-            // Check if the object is 'rpc' (or a variable containing rpc)
-            if (ts.isIdentifier(expression) && expression.text === 'rpc') {
-                // This is rpc.invoke - now we need to find the parent call expression
-                const parent = node.parent;
-                if (ts.isCallExpression(parent) && parent.expression === node) {
-                    // This is rpc.invoke('function-name')
-                    const [firstArg] = parent.arguments;
-                    if (firstArg) {
-                        // Extract the function name from string literal
-                        if (ts.isStringLiteral(firstArg)) {
-                            const functionName = firstArg.text;
-                            logger.debug(`• Found RPC invocation: ${functionName}`);
-                            state.rpc.invokedFunctions.add(functionName);
-                        }
-                        // Handle template literals like `function-${name}`
-                        else if (ts.isTemplateExpression(firstArg) ||
-                            ts.isNoSubstitutionTemplateLiteral(firstArg)) {
-                            logger.warn(`• Found dynamic RPC invocation: ${firstArg.getText()}`);
-                            logger.warn(`\tYou can only use string literals for RPC function names, with ' or " and not \``);
-                        }
+    // Look for call expressions: external('ext:hello') or rpc.invoke('...')
+    if (ts.isCallExpression(node)) {
+        const { expression, arguments: args } = node;
+        // Check for external('namespace:function') calls
+        if (ts.isIdentifier(expression) && expression.text === 'external') {
+            const [firstArg] = args;
+            if (firstArg && ts.isStringLiteral(firstArg)) {
+                const functionRef = firstArg.text;
+                logger.debug(`• Found external() call: ${functionRef}`);
+                state.rpc.invokedFunctions.add(functionRef);
+                const namespace = extractNamespace(functionRef);
+                if (namespace) {
+                    logger.debug(`  → External package detected: ${namespace}`);
+                    state.rpc.usedExternalPackages.add(namespace);
+                }
+            }
+        }
+        // Check for workflow('...'), workflowStart('...'), workflowRun('...'), workflowStatus('...'), graphStart('...') calls
+        if (ts.isIdentifier(expression) &&
+            (expression.text === 'workflow' ||
+                expression.text === 'workflowStart' ||
+                expression.text === 'workflowRun' ||
+                expression.text === 'workflowStatus' ||
+                expression.text === 'graphStart')) {
+            const [firstArg] = args;
+            if (firstArg && ts.isStringLiteral(firstArg)) {
+                const workflowName = firstArg.text;
+                logger.debug(`• Found ${expression.text}() call: ${workflowName}`);
+                state.workflows.invokedWorkflows.add(workflowName);
+            }
+        }
+        // Check for rpc.invoke('...') calls
+        if (ts.isPropertyAccessExpression(expression) &&
+            expression.name.text === 'invoke' &&
+            ts.isIdentifier(expression.expression) &&
+            expression.expression.text === 'rpc') {
+            const [firstArg] = args;
+            if (firstArg) {
+                if (ts.isStringLiteral(firstArg)) {
+                    const functionRef = firstArg.text;
+                    logger.debug(`• Found RPC invocation: ${functionRef}`);
+                    state.rpc.invokedFunctions.add(functionRef);
+                    const namespace = extractNamespace(functionRef);
+                    if (namespace) {
+                        logger.debug(`  → External package detected: ${namespace}`);
+                        state.rpc.usedExternalPackages.add(namespace);
                     }
                 }
+                // Handle template literals like `function-${name}`
+                else if (ts.isTemplateExpression(firstArg) ||
+                    ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                    logger.warn(`• Found dynamic RPC invocation: ${firstArg.getText()}`);
+                    logger.warn(`\tYou can only use string literals for RPC function names, with ' or " and not \``);
+                }
             }
         }
     }

package/dist/add/add-schedule.js

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractFunctionName, makeContextBasedId, } 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';
@@ -23,24 +23,30 @@ export const addSchedule = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
         const scheduleValue = getPropertyValue(obj, 'schedule');
-        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Scheduler', nameValue, logger);
+        const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'Scheduler', nameValue, logger);
+        if (disabled)
+            return;
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
             logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for scheduled task '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        const extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+        let pikkuFuncId = extracted.pikkuFuncId;
+        if (pikkuFuncId.startsWith('__temp_') && nameValue) {
+            pikkuFuncId = makeContextBasedId('scheduler', nameValue);
+        }
         if (!nameValue || !scheduleValue) {
             return;
         }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- track used functions/middleware for service aggregation ---
-        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        state.serviceAggregation.usedFunctions.add(pikkuFuncId);
         extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
         state.scheduledTasks.meta[nameValue] = {
-            pikkuFuncName,
+            pikkuFuncId,
             name: nameValue,
             schedule: scheduleValue,
             summary,

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

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

package/dist/add/add-secret.js

@@ -0,0 +1,82 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getArrayPropertyValue, } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+import { createAddKeyedWiring } from './add-keyed-wiring.js';
+export const addSecret = createAddKeyedWiring({
+    functionName: 'wireSecret',
+    idField: 'secretId',
+    label: 'Secret',
+    schemaPrefix: 'SecretSchema',
+    getState: (state) => state.secrets,
+});
+export const addOAuth2Credential = (logger, node, _checker, state, _options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) ||
+        expression.text !== 'wireOAuth2Credential') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const displayNameValue = getPropertyValue(obj, 'displayName');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        const secretIdValue = getPropertyValue(obj, 'secretId');
+        const tokenSecretIdValue = getPropertyValue(obj, 'tokenSecretId');
+        const authorizationUrlValue = getPropertyValue(obj, 'authorizationUrl');
+        const tokenUrlValue = getPropertyValue(obj, 'tokenUrl');
+        const scopesValue = getArrayPropertyValue(obj, 'scopes');
+        const pkceValue = getPropertyValue(obj, 'pkce');
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "OAuth2 Credential is missing the required 'name' property.");
+            return;
+        }
+        if (!displayNameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'displayName' property.`);
+            return;
+        }
+        if (!secretIdValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'secretId' property.`);
+            return;
+        }
+        if (!tokenSecretIdValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'tokenSecretId' property.`);
+            return;
+        }
+        if (!authorizationUrlValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'authorizationUrl' property.`);
+            return;
+        }
+        if (!tokenUrlValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'tokenUrl' property.`);
+            return;
+        }
+        if (!scopesValue || scopesValue.length === 0) {
+            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'scopes' property.`);
+            return;
+        }
+        const sourceFile = node.getSourceFile().fileName;
+        state.secrets.files.add(sourceFile);
+        state.secrets.definitions.push({
+            name: nameValue,
+            displayName: displayNameValue,
+            description: descriptionValue || undefined,
+            secretId: secretIdValue,
+            oauth2: {
+                tokenSecretId: tokenSecretIdValue,
+                authorizationUrl: authorizationUrlValue,
+                tokenUrl: tokenUrlValue,
+                scopes: scopesValue,
+                pkce: pkceValue || undefined,
+            },
+            sourceFile,
+        });
+    }
+};