@pikku/inspector 0.10.1 → 0.11.0

package/dist/utils/extract-node-value.js

@@ -0,0 +1,79 @@
+import * as ts from 'typescript';
+/**
+ * Extract string literal value from a TypeScript node.
+ * Handles string literals, template literals (including placeholders),
+ * and constant variable references.
+ */
+export function extractStringLiteral(node, checker) {
+    if (ts.isStringLiteral(node)) {
+        return node.text;
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(node)) {
+        return node.text;
+    }
+    if (ts.isTemplateExpression(node)) {
+        // reconstruct: `head + ${expr} + middle + ${expr} + tail`
+        let result = node.head.text;
+        for (const span of node.templateSpans) {
+            const exprText = span.expression.getText();
+            result += '${' + exprText + '}' + span.literal.text;
+        }
+        return result;
+    }
+    // Try to evaluate constant identifiers
+    if (ts.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (symbol?.valueDeclaration &&
+            ts.isVariableDeclaration(symbol.valueDeclaration)) {
+            const init = symbol.valueDeclaration.initializer;
+            if (init) {
+                return extractStringLiteral(init, checker);
+            }
+        }
+    }
+    throw new Error('Unable to extract string literal from node');
+}
+/**
+ * Check if node is string-like (string literal or template expression)
+ */
+export function isStringLike(node, _checker) {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return true;
+    }
+    // Check if it's a template string with substitutions
+    if (ts.isTemplateExpression(node)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if node is function-like (arrow, function expression, or function declaration)
+ */
+export function isFunctionLike(node) {
+    return (ts.isArrowFunction(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isFunctionDeclaration(node));
+}
+/**
+ * Extract number literal value from a node
+ */
+export function extractNumberLiteral(node) {
+    if (ts.isNumericLiteral(node)) {
+        return Number(node.text);
+    }
+    return null;
+}
+/**
+ * Extract a property value from an object literal expression
+ * Returns the extracted value or null if not found/cannot extract
+ */
+export function extractPropertyString(objNode, propertyName, checker) {
+    for (const prop of objNode.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propertyName) {
+            return extractStringLiteral(prop.initializer, checker);
+        }
+    }
+    return null;
+}

package/dist/utils/post-process.d.ts

@@ -13,4 +13,4 @@ export declare function extractWireNames(list?: MiddlewareMetadata[] | Permissio
  * Note: usedFunctions, usedMiddleware, and usedPermissions are tracked directly
  * in the add-* methods during AST traversal for efficiency.
  */
-export declare function aggregateRequiredServices(state: InspectorState): void;
+export declare function aggregateRequiredServices(state: InspectorState | Omit<InspectorState, 'typesLookup'>): void;

package/dist/utils/post-process.js

@@ -1,3 +1,4 @@
+import { extractTypeKeys } from './type-utils.js';
 /**
  * Helper to extract wire-level middleware/permission names from metadata.
  * Only extracts type:'wire' variants (individual middleware/permissions).
@@ -39,6 +40,33 @@ function expandAndAddGroupServices(list, state, addServices, isMiddleware) {
         }
     }
 }
+/**
+ * Extracts all service names from SingletonServices and Services types.
+ * This provides the complete list of available services for code generation.
+ * Only runs if typesLookup is available (omitted in deserialized states).
+ */
+function extractAllServices(state) {
+    // Skip if typesLookup is not available (e.g., deserialized state)
+    if (!('typesLookup' in state)) {
+        return;
+    }
+    // Extract all singleton services from the SingletonServices type
+    const singletonServicesTypes = state.typesLookup.get('SingletonServices');
+    if (singletonServicesTypes && singletonServicesTypes.length > 0) {
+        const singletonServiceNames = extractTypeKeys(singletonServicesTypes[0]);
+        state.serviceAggregation.allSingletonServices = singletonServiceNames.sort();
+    }
+    // Extract all services from the Services type
+    const servicesTypes = state.typesLookup.get('Services');
+    if (servicesTypes && servicesTypes.length > 0) {
+        const allServiceNames = extractTypeKeys(servicesTypes[0]);
+        // Session services are those in Services but not in SingletonServices
+        const singletonSet = new Set(state.serviceAggregation.allSingletonServices);
+        state.serviceAggregation.allSessionServices = allServiceNames
+            .filter((name) => !singletonSet.has(name))
+            .sort();
+    }
+}
 /**
  * Aggregates all required services from wired functions, middleware, and permissions.
  * Must be called after AST traversal completes.
@@ -47,6 +75,8 @@ function expandAndAddGroupServices(list, state, addServices, isMiddleware) {
  * in the add-* methods during AST traversal for efficiency.
  */
 export function aggregateRequiredServices(state) {
+    // First, extract all available services from types
+    extractAllServices(state);
     const { requiredServices, usedFunctions, usedMiddleware, usedPermissions } = state.serviceAggregation;
     // Internal services (always excluded from tree-shaking)
     const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession']);

package/dist/utils/serialize-inspector-state.d.ts

@@ -123,6 +123,10 @@ export interface SerializableInspectorState {
         meta: InspectorState['queueWorkers']['meta'];
         files: string[];
     };
+    workflows: {
+        meta: InspectorState['workflows']['meta'];
+        files: string[];
+    };
     rpc: {
         internalMeta: InspectorState['rpc']['internalMeta'];
         internalFiles: Array<[string, {
@@ -165,6 +169,8 @@ export interface SerializableInspectorState {
         usedFunctions: string[];
         usedMiddleware: string[];
         usedPermissions: string[];
+        allSingletonServices: string[];
+        allSessionServices: string[];
     };
 }
 /**

package/dist/utils/serialize-inspector-state.js

@@ -50,6 +50,10 @@ export function serializeInspectorState(state) {
             meta: state.queueWorkers.meta,
             files: Array.from(state.queueWorkers.files),
         },
+        workflows: {
+            meta: state.workflows.meta,
+            files: Array.from(state.workflows.files),
+        },
         rpc: {
             internalMeta: state.rpc.internalMeta,
             internalFiles: Array.from(state.rpc.internalFiles.entries()),
@@ -80,6 +84,8 @@ export function serializeInspectorState(state) {
             usedFunctions: Array.from(state.serviceAggregation.usedFunctions),
             usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
             usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
+            allSingletonServices: state.serviceAggregation.allSingletonServices,
+            allSessionServices: state.serviceAggregation.allSessionServices,
         },
     };
 }
@@ -135,6 +141,10 @@ export function deserializeInspectorState(data) {
             meta: data.queueWorkers.meta,
             files: new Set(data.queueWorkers.files),
         },
+        workflows: {
+            meta: data.workflows.meta,
+            files: new Set(data.workflows.files),
+        },
         rpc: {
             internalMeta: data.rpc.internalMeta,
             internalFiles: new Map(data.rpc.internalFiles),
@@ -165,6 +175,8 @@ export function deserializeInspectorState(data) {
             usedFunctions: new Set(data.serviceAggregation.usedFunctions),
             usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
             usedPermissions: new Set(data.serviceAggregation.usedPermissions),
+            allSingletonServices: data.serviceAggregation.allSingletonServices,
+            allSessionServices: data.serviceAggregation.allSessionServices,
         },
     };
 }

package/dist/utils/type-utils.d.ts

@@ -1,3 +1,7 @@
 import * as ts from 'typescript';
 export declare const extractTypeKeys: (type: ts.Type) => string[];
+/**
+ * Resolve an identifier or call expression to the actual function declaration
+ */
+export declare function resolveFunctionDeclaration(node: ts.Node, checker: ts.TypeChecker): ts.Node | null;
 export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;

package/dist/utils/type-utils.js

@@ -2,6 +2,61 @@ import * as ts from 'typescript';
 export const extractTypeKeys = (type) => {
     return type.getProperties().map((symbol) => symbol.getName());
 };
+/**
+ * Resolve an identifier or call expression to the actual function declaration
+ */
+export function resolveFunctionDeclaration(node, checker) {
+    // If it's already a function-like node, return it
+    if (ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node)) {
+        return node;
+    }
+    // If it's a call expression (e.g., pikkuWorkflowFunc(...)), get its first argument
+    if (ts.isCallExpression(node) && node.arguments.length > 0) {
+        const firstArg = node.arguments[0];
+        if (ts.isFunctionExpression(firstArg) || ts.isArrowFunction(firstArg)) {
+            return firstArg;
+        }
+    }
+    // If it's an identifier, resolve to declaration
+    if (ts.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (!symbol)
+            return null;
+        // Try valueDeclaration first, then fallback to declarations[0]
+        const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+        if (!decl)
+            return null;
+        // If it's an import specifier, resolve the aliased symbol
+        if (ts.isImportSpecifier(decl)) {
+            const aliasedSymbol = checker.getAliasedSymbol(symbol);
+            if (aliasedSymbol) {
+                const aliasedDecl = aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0];
+                if (aliasedDecl) {
+                    // For variable declarations, get the initializer
+                    if (ts.isVariableDeclaration(aliasedDecl) &&
+                        aliasedDecl.initializer) {
+                        return resolveFunctionDeclaration(aliasedDecl.initializer, checker);
+                    }
+                    // For function declarations, return directly
+                    if (ts.isFunctionDeclaration(aliasedDecl)) {
+                        return aliasedDecl;
+                    }
+                }
+            }
+        }
+        // If it's a variable declaration, get the initializer
+        if (ts.isVariableDeclaration(decl) && decl.initializer) {
+            return resolveFunctionDeclaration(decl.initializer, checker);
+        }
+        // If it's a function declaration
+        if (ts.isFunctionDeclaration(decl)) {
+            return decl;
+        }
+    }
+    return null;
+}
 export function getPropertyAssignmentInitializer(obj, propName, followShorthand = false, checker) {
     for (const prop of obj.properties) {
         // ①  foo: () => {}
@@ -22,17 +77,19 @@ export function getPropertyAssignmentInitializer(obj, propName, followShorthand
             prop.name.text === propName) {
             if (!checker)
                 return prop.name; // best effort without a checker
-            let sym = checker.getSymbolAtLocation(prop.name);
+            // Use the proper TypeScript API for shorthand property resolution
+            let sym = checker.getShorthandAssignmentValueSymbol(prop);
             if (sym && sym.flags & ts.SymbolFlags.Alias) {
                 sym = checker.getAliasedSymbol(sym);
             }
             const decl = sym?.declarations?.[0];
-            // const foo = () => {}
+            // const foo = () => {} or const foo = pikkuFunc(...)
             if (decl &&
                 ts.isVariableDeclaration(decl) &&
                 decl.initializer &&
                 (ts.isArrowFunction(decl.initializer) ||
-                    ts.isFunctionExpression(decl.initializer))) {
+                    ts.isFunctionExpression(decl.initializer) ||
+                    ts.isCallExpression(decl.initializer))) {
                 return decl.initializer;
             }
             // function foo() {}

package/dist/visit.js

@@ -4,6 +4,7 @@ import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
 import { addHTTPRoute } from './add/add-http-route.js';
 import { addSchedule } from './add/add-schedule.js';
 import { addQueueWorker } from './add/add-queue-worker.js';
+import { addWorkflow } from './add/add-workflow.js';
 import { addMCPResource } from './add/add-mcp-resource.js';
 import { addMCPTool } from './add/add-mcp-tool.js';
 import { addMCPPrompt } from './add/add-mcp-prompt.js';
@@ -24,6 +25,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addRPCInvocations(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
+    addWorkflow(logger, node, checker, state, options);
     ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));
 };
 export const visitRoutes = (logger, checker, node, state, options) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -16,7 +16,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.10.1",
+    "@pikku/core": "^0.11.0",
     "path-to-regexp": "^8.3.0",
     "typescript": "^5.9"
   },

package/src/add/add-channel.ts

@@ -136,7 +136,15 @@ export function addMessagesRoutes(
       const init = getInitializerOf(routeElem)
       if (!init) continue
 
-      const routeKey = routeElem.name!.getText()
+      // Get the route key, stripping quotes if it's a string literal
+      const routeName = routeElem.name
+      if (!routeName) continue
+
+      let routeKey = routeName.getText()
+      // For string literals like 'greet' or "greet", strip the quotes
+      if (ts.isStringLiteral(routeName)) {
+        routeKey = routeName.text
+      }
 
       // For shorthand properties, we need to resolve the identifier to its declaration
       if (ts.isShorthandPropertyAssignment(routeElem)) {
@@ -196,8 +204,17 @@ export function addMessagesRoutes(
                     // Look up in the registry
                     const fnMeta = state.functions.meta[handlerName]
                     if (fnMeta) {
+                      // Resolve middleware for this route
+                      const routeTags = ts.isObjectLiteralExpression(init)
+                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                        : undefined
+                      const routeMiddleware = ts.isObjectLiteralExpression(init)
+                        ? resolveMiddleware(state, init, routeTags, checker)
+                        : undefined
+
                       result[channelKey]![routeKey] = {
                         pikkuFuncName: handlerName,
+                        middleware: routeMiddleware,
                       }
                       continue
                     }
@@ -214,8 +231,17 @@ export function addMessagesRoutes(
                   // Look up in the registry
                   const fnMeta = state.functions.meta[handlerName]
                   if (fnMeta) {
+                    // Resolve middleware for this route
+                    const routeTags = ts.isObjectLiteralExpression(init)
+                      ? getPropertyTags(init, 'channel', channelKey, logger)
+                      : undefined
+                    const routeMiddleware = ts.isObjectLiteralExpression(init)
+                      ? resolveMiddleware(state, init, routeTags, checker)
+                      : undefined
+
                     result[channelKey]![routeKey] = {
                       pikkuFuncName: handlerName,
+                      middleware: routeMiddleware,
                     }
                     continue
                   }
@@ -249,8 +275,24 @@ export function addMessagesRoutes(
 
                         const fnMeta = state.functions.meta[handlerName]
                         if (fnMeta) {
+                          // Resolve middleware for this route
+                          const routeTags = ts.isObjectLiteralExpression(init)
+                            ? getPropertyTags(
+                                init,
+                                'channel',
+                                channelKey,
+                                logger
+                              )
+                            : undefined
+                          const routeMiddleware = ts.isObjectLiteralExpression(
+                            init
+                          )
+                            ? resolveMiddleware(state, init, routeTags, checker)
+                            : undefined
+
                           result[channelKey]![routeKey] = {
                             pikkuFuncName: handlerName,
+                            middleware: routeMiddleware,
                           }
                           continue
                         }
@@ -264,8 +306,24 @@ export function addMessagesRoutes(
 
                         const fnMeta = state.functions.meta[handlerName]
                         if (fnMeta) {
+                          // Resolve middleware for this route
+                          const routeTags = ts.isObjectLiteralExpression(init)
+                            ? getPropertyTags(
+                                init,
+                                'channel',
+                                channelKey,
+                                logger
+                              )
+                            : undefined
+                          const routeMiddleware = ts.isObjectLiteralExpression(
+                            init
+                          )
+                            ? resolveMiddleware(state, init, routeTags, checker)
+                            : undefined
+
                           result[channelKey]![routeKey] = {
                             pikkuFuncName: handlerName,
+                            middleware: routeMiddleware,
                           }
                           continue
                         }
@@ -336,8 +394,17 @@ export function addMessagesRoutes(
               const fnMeta = state.functions.meta[handlerName]
 
               if (fnMeta) {
+                // Resolve middleware for this route
+                const routeTags = ts.isObjectLiteralExpression(init)
+                  ? getPropertyTags(init, 'channel', channelKey, logger)
+                  : undefined
+                const routeMiddleware = ts.isObjectLiteralExpression(init)
+                  ? resolveMiddleware(state, init, routeTags, checker)
+                  : undefined
+
                 result[channelKey]![routeKey] = {
                   pikkuFuncName: handlerName,
+                  middleware: routeMiddleware,
                 }
                 continue // Skip the normal processing below
               }
@@ -368,8 +435,18 @@ export function addMessagesRoutes(
         continue
       }
 
+      // Resolve middleware and permissions for this route
+      // Check if the route config is an object literal with middleware/permissions
+      const routeTags = ts.isObjectLiteralExpression(init)
+        ? getPropertyTags(init, 'channel', channelKey, logger)
+        : undefined
+      const routeMiddleware = ts.isObjectLiteralExpression(init)
+        ? resolveMiddleware(state, init, routeTags, checker)
+        : undefined
+
       result[channelKey]![routeKey] = {
         pikkuFuncName: handlerName,
+        middleware: routeMiddleware,
       }
     }
   }
@@ -417,13 +494,13 @@ export const addChannel: AddWiring = (
   const connect = getPropertyAssignmentInitializer(
     obj,
     'onConnect',
-    false,
+    true,
     checker
   )
   const disconnect = getPropertyAssignmentInitializer(
     obj,
     'onDisconnect',
-    false,
+    true,
     checker
   )
 
@@ -432,28 +509,26 @@ export const addChannel: AddWiring = (
   const onMsgProp = getPropertyAssignmentInitializer(
     obj,
     'onMessage',
-    false,
+    true,
     checker
   )
 
   if (onMsgProp) {
-    const handlerName =
-      onMsgProp &&
-      getHandlerNameFromExpression(onMsgProp, checker, state.rootDir)
-    const fnMeta = handlerName && state.functions.meta[handlerName]
+    const { pikkuFuncName } = extractFunctionName(
+      onMsgProp,
+      checker,
+      state.rootDir
+    )
+    const fnMeta = state.functions.meta[pikkuFuncName]
     if (!fnMeta) {
-      console.error(
-        `No function metadata for onMessage handler '${handlerName}'`
+      logger.critical(
+        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+        `No function metadata found for onMessage handler '${pikkuFuncName}'`
       )
-      throw new Error()
-    } else {
-      message = {
-        pikkuFuncName: extractFunctionName(
-          onMsgProp as any,
-          checker,
-          state.rootDir
-        ).pikkuFuncName,
-      }
+      return
+    }
+    message = {
+      pikkuFuncName,
     }
   }
 

package/src/add/add-functions.ts

@@ -305,6 +305,7 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
 
   let tags: string[] | undefined
   let expose: boolean | undefined
+  let internal: boolean | undefined
   let docs: PikkuDocs | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
 
@@ -318,6 +319,7 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
     objectNode = handlerNode
     tags = (getPropertyValue(handlerNode, 'tags') as string[]) || undefined
     expose = getPropertyValue(handlerNode, 'expose') as boolean | undefined
+    internal = getPropertyValue(handlerNode, 'internal') as boolean | undefined
     docs = getPropertyValue(handlerNode, 'docs') as PikkuDocs | undefined
 
     const fnProp = getPropertyAssignmentInitializer(
@@ -454,6 +456,7 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
     inputs: inputNames.filter((n) => n !== 'void') ?? null,
     outputs: outputNames.filter((n) => n !== 'void') ?? null,
     expose: expose || undefined,
+    internal: internal || undefined,
     tags: tags || undefined,
     docs: docs || undefined,
     isDirectFunction,
@@ -481,6 +484,11 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
       return
     }
 
+    // Mark internal functions as invoked to force bundling
+    if (internal) {
+      state.rpc.invokedFunctions.add(pikkuFuncName)
+    }
+
     if (expose) {
       state.rpc.exposedMeta[name] = pikkuFuncName
       state.rpc.exposedFiles.set(name, {
@@ -496,8 +504,8 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
 
     // But we only import the actual function if it's actually invoked to keep
     // bundle size down
-    if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose) {
-      state.rpc.internalFiles.set(name, {
+    if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose || internal) {
+      state.rpc.internalFiles.set(pikkuFuncName, {
         path: node.getSourceFile().fileName,
         exportedName,
       })