@pikku/inspector 0.9.2 → 0.9.4

package/src/add-functions.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { InspectorState, InspectorFilters, InspectorLogger } from './types.js'
+import { InspectorLogger, InspectorState } from './types.js'
 import { TypesMap } from './types-map.js'
 import {
   extractFunctionName,
@@ -84,6 +84,25 @@ const resolveTypeImports = (
         typeRef.typeArguments?.forEach(visitType)
       }
     }
+
+    // Always traverse type arguments for thorough type collection
+    if (currentType.aliasTypeArguments) {
+      currentType.aliasTypeArguments.forEach(visitType)
+    }
+
+    // Always handle intersections and unions
+    if (currentType.isUnionOrIntersection()) {
+      currentType.types.forEach(visitType)
+    }
+
+    // Always handle object types with type arguments
+    if (
+      currentType.flags & ts.TypeFlags.Object &&
+      (currentType as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference
+    ) {
+      const typeRef = currentType as ts.TypeReference
+      typeRef.typeArguments?.forEach(visitType)
+    }
   }
 
   visitType(type)
@@ -232,7 +251,6 @@ export function addFunctions(
   node: ts.Node,
   checker: ts.TypeChecker,
   state: InspectorState,
-  filters: InspectorFilters,
   logger: InspectorLogger
 ) {
   if (!ts.isCallExpression(node)) return
@@ -267,7 +285,10 @@ export function addFunctions(
   // determine the actual handler expression:
   // either the `func` prop or the first argument directly
   let handlerNode: ts.Expression = args[0]!
+  let isDirectFunction = true // Default to direct function format
+
   if (ts.isObjectLiteralExpression(handlerNode)) {
+    isDirectFunction = false // This is object format with func property
     tags = (getPropertyValue(handlerNode, 'tags') as string[]) || undefined
     expose = getPropertyValue(handlerNode, 'expose') as boolean | undefined
     docs = getPropertyValue(handlerNode, 'docs') as PikkuDocs | undefined
@@ -282,7 +303,7 @@ export function addFunctions(
       !fnProp ||
       (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))
     ) {
-      console.error(`• No valid 'func' property found for ${pikkuFuncName}.`)
+      logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`)
       return
     }
     handlerNode = fnProp
@@ -292,7 +313,7 @@ export function addFunctions(
     !ts.isArrowFunction(handlerNode) &&
     !ts.isFunctionExpression(handlerNode)
   ) {
-    console.error(`• Handler for ${name} is not a function.`)
+    logger.error(`• Handler for ${name} is not a function.`)
     return
   }
 
@@ -334,7 +355,7 @@ export function addFunctions(
     genericTypes[0]
   )
   // if (inputTypes.length === 0) {
-  //   console.debug(
+  //   logger.debug(
   //     `\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`
   //   )
   // }
@@ -365,7 +386,7 @@ export function addFunctions(
   }
 
   if (inputNames.length > 1) {
-    console.warn(
+    logger.warn(
       'More than one input type detected, only the first one will be used as a schema.'
     )
   }
@@ -374,34 +395,42 @@ export function addFunctions(
     pikkuFuncName,
     name,
     services,
-    schemaName: inputNames[0] ?? null,
+    inputSchemaName: inputNames[0] ?? null,
+    outputSchemaName: outputNames[0] ?? null,
     inputs: inputNames.filter((n) => n !== 'void') ?? null,
     outputs: outputNames.filter((n) => n !== 'void') ?? null,
-    expose,
-    tags,
-    docs,
+    expose: expose || undefined,
+    tags: tags || undefined,
+    docs: docs || undefined,
+    isDirectFunction,
   }
 
-  if (explicitName || exportedName) {
+  if (exportedName || explicitName) {
     if (!exportedName) {
-      console.error(
+      logger.error(
         `• Function with explicit name '${name}' is not exported, this is not allowed.`
       )
       return
     }
-    if (state.rpc.meta[name]) {
-      console.error(`• Function name '${name}' already exists, skipping.`)
-      return
+
+    if (expose) {
+      state.rpc.exposedMeta[name] = pikkuFuncName
+      state.rpc.exposedFiles.set(name, {
+        path: node.getSourceFile().fileName,
+        exportedName,
+      })
     }
-    state.rpc.meta[name] = {
-      pikkuFuncName,
-      exposed: false,
+
+    // We add it to internal meta to allow autocomplete for everything
+    state.rpc.internalMeta[name] = pikkuFuncName
+
+    // But we only import the actual function if it's actually invoked to keep
+    // bundle size down
+    if (state.rpc.invokedFunctions.has(pikkuFuncName)) {
+      state.rpc.internalFiles.set(name, {
+        path: node.getSourceFile().fileName,
+        exportedName,
+      })
     }
-    state.functions.files.set(name, {
-      path: node.getSourceFile().fileName,
-      exportedName,
-    })
-  } else {
-    console.log(`• Function name '${name}' not exported, skipping.`)
   }
 }

package/src/add-http-route.ts

@@ -116,7 +116,7 @@ export const addHTTPRoute = (
 
   // --- record route ---
   state.http.files.add(node.getSourceFile().fileName)
-  state.http.meta.push({
+  state.http.meta[method][route] = {
     pikkuFuncName: funcName,
     route,
     method: method as HTTPMethod,
@@ -125,5 +125,5 @@ export const addHTTPRoute = (
     inputTypes,
     docs,
     tags,
-  })
+  }
 }

package/src/add-middleware.ts

@@ -0,0 +1,51 @@
+import * as ts from 'typescript'
+import { InspectorLogger, InspectorState } from './types.js'
+import { extractFunctionName, extractServicesFromFunction } from './utils.js'
+
+/**
+ * Inspect pikkuMiddleware calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export function addMiddleware(
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  logger: InspectorLogger
+) {
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args } = node
+
+  // only handle calls like pikkuMiddleware(...)
+  if (!ts.isIdentifier(expression)) {
+    return
+  }
+
+  if (expression.text !== 'pikkuMiddleware') {
+    return
+  }
+
+  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(', ')}`
+  )
+}

package/src/add-permission.ts

@@ -0,0 +1,53 @@
+import * as ts from 'typescript'
+import { InspectorLogger, InspectorState } from './types.js'
+import { extractFunctionName, extractServicesFromFunction } from './utils.js'
+
+/**
+ * Inspect pikkuPermission calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export function addPermission(
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  logger: InspectorLogger
+) {
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args } = node
+
+  // only handle calls like pikkuPermission(...)
+  if (!ts.isIdentifier(expression)) {
+    return
+  }
+
+  if (expression.text !== 'pikkuPermission') {
+    return
+  }
+
+  const handlerNode = args[0]
+  if (!handlerNode) return
+
+  if (
+    !ts.isArrowFunction(handlerNode) &&
+    !ts.isFunctionExpression(handlerNode)
+  ) {
+    logger.error(`• Handler for pikkuPermission is not a function.`)
+    return
+  }
+
+  const services = extractServicesFromFunction(handlerNode)
+
+  const { pikkuFuncName, exportedName } = extractFunctionName(node, checker)
+
+  state.permissions.meta[pikkuFuncName] = {
+    services,
+    sourceFile: node.getSourceFile().fileName,
+    position: node.getStart(),
+    exportedName,
+  }
+
+  logger.debug(
+    `• Found permission with services: ${services.services.join(', ')}`
+  )
+}

package/src/add-rpc-invocations.ts

@@ -0,0 +1,49 @@
+import * as ts from 'typescript'
+import { InspectorState, InspectorLogger } from './types.js'
+
+/**
+ * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ */
+export function addRPCInvocations(
+  node: ts.Node,
+  state: InspectorState,
+  logger: InspectorLogger
+) {
+  // 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 \``
+              )
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/inspector.ts

@@ -36,11 +36,18 @@ export const inspect = (
     functions: {
       typesMap: new TypesMap(),
       meta: {},
-      files: new Map(),
     },
     http: {
       metaInputTypes: new Map(),
-      meta: [],
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
       files: new Set(),
     },
     channels: {
@@ -56,7 +63,11 @@ export const inspect = (
       files: new Set(),
     },
     rpc: {
-      meta: {},
+      internalMeta: {},
+      internalFiles: new Map(),
+      exposedMeta: {},
+      exposedFiles: new Map(),
+      invokedFunctions: new Set(),
     },
     mcpEndpoints: {
       resourcesMeta: {},
@@ -64,6 +75,12 @@ export const inspect = (
       promptsMeta: {},
       files: new Set(),
     },
+    middleware: {
+      meta: {},
+    },
+    permissions: {
+      meta: {},
+    },
   }
 
   // First sweep: add all functions

package/src/types.ts

@@ -4,8 +4,7 @@ import { ScheduledTasksMeta } from '@pikku/core/scheduler'
 import { queueWorkersMeta } from '@pikku/core/queue'
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
 import { TypesMap } from './types-map.js'
-import { FunctionsMeta } from '@pikku/core'
-import { RPCMeta } from '@pikku/core/rpc'
+import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core'
 
 export type PathToNameAndType = Map<
   string,
@@ -29,7 +28,6 @@ export interface InspectorHTTPState {
 
 export interface InspectorFunctionState {
   typesMap: TypesMap
-  files: Map<string, { path: string; exportedName: string }>
   meta: FunctionsMeta
 }
 
@@ -38,6 +36,30 @@ export interface InspectorChannelState {
   files: Set<string>
 }
 
+export interface InspectorMiddlewareState {
+  meta: Record<
+    string,
+    {
+      services: FunctionServicesMeta
+      sourceFile: string
+      position: number
+      exportedName: string | null
+    }
+  >
+}
+
+export interface InspectorPermissionState {
+  meta: Record<
+    string,
+    {
+      services: FunctionServicesMeta
+      sourceFile: string
+      position: number
+      exportedName: string | null
+    }
+  >
+}
+
 export type InspectorFilters = {
   tags?: string[]
   types?: string[]
@@ -69,7 +91,11 @@ export interface InspectorState {
     files: Set<string>
   }
   rpc: {
-    meta: Record<string, RPCMeta>
+    internalMeta: Record<string, string>
+    internalFiles: Map<string, { path: string; exportedName: string }>
+    exposedMeta: Record<string, string>
+    exposedFiles: Map<string, { path: string; exportedName: string }>
+    invokedFunctions: Set<string> // Track functions called via rpc.invoke()
   }
   mcpEndpoints: {
     resourcesMeta: MCPResourceMeta
@@ -77,4 +103,6 @@ export interface InspectorState {
     promptsMeta: MCPPromptMeta
     files: Set<string>
   }
+  middleware: InspectorMiddlewareState
+  permissions: InspectorPermissionState
 }

package/src/utils.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript'
 import { InspectorFilters, InspectorLogger } from './types.js'
-import { PikkuWiringTypes } from '@pikku/core'
+import { PikkuWiringTypes, FunctionServicesMeta } from '@pikku/core'
 
 type ExtractedFunctionName = {
   pikkuFuncName: string
@@ -289,7 +289,7 @@ export function extractFunctionName(
       const decls = resolvedSym.declarations ?? []
       if (decls.length > 0) {
         const decl = decls[0]!
-        // Check if the declaration is a variable that uses pikkuSessionlessFunc
+        // Check if the declaration is a variable that uses a pikkuFun
         if (ts.isVariableDeclaration(decl) && decl.initializer) {
           if (
             ts.isCallExpression(decl.initializer) &&
@@ -321,6 +321,8 @@ export function extractFunctionName(
                 ts.isIdentifier(decl.name)
               ) {
                 result.exportedName = decl.name.text
+                // CRITICAL FIX: Use exported name as pikkuFuncName for consistency
+                result.pikkuFuncName = decl.name.text
               } else if (ts.isIdentifier(decl.name)) {
                 // If not exported, still capture the variable name
                 result.localName = decl.name.text
@@ -717,6 +719,12 @@ export function extractFunctionName(
 
   // Apply name priority logic
   populateNameByPriority(result)
+
+  // CRITICAL FIX: If we have an exported name, use it as the pikkuFuncName for consistent lookup
+  if (result.exportedName && !result.explicitName) {
+    result.pikkuFuncName = result.exportedName
+  }
+
   return result
 }
 
@@ -910,3 +918,36 @@ export const matchesFilters = (
 
   return true
 }
+
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export function extractServicesFromFunction(
+  handlerNode: ts.FunctionExpression | ts.ArrowFunction
+): FunctionServicesMeta {
+  const services: FunctionServicesMeta = {
+    optimized: true,
+    services: [],
+  }
+
+  const firstParam = handlerNode.parameters[0]
+  if (firstParam) {
+    if (ts.isObjectBindingPattern(firstParam.name)) {
+      for (const elem of firstParam.name.elements) {
+        const original =
+          elem.propertyName && ts.isIdentifier(elem.propertyName)
+            ? elem.propertyName.text
+            : ts.isIdentifier(elem.name)
+              ? elem.name.text
+              : undefined
+        if (original) {
+          services.services.push(original)
+        }
+      }
+    } else if (ts.isIdentifier(firstParam.name)) {
+      services.optimized = false
+    }
+  }
+
+  return services
+}

package/src/visit.ts

@@ -10,6 +10,9 @@ import { addMCPPrompt } from './add-mcp-prompt.js'
 import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
 import { addFunctions } from './add-functions.js'
 import { addChannel } from './add-channel.js'
+import { addRPCInvocations } from './add-rpc-invocations.js'
+import { addMiddleware } from './add-middleware.js'
+import { addPermission } from './add-permission.js'
 
 export const visitSetup = (
   checker: ts.TypeChecker,
@@ -54,7 +57,7 @@ export const visitSetup = (
   )
 
   addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
-  addFunctions(node, checker, state, filters, logger)
+  addRPCInvocations(node, state, logger)
 
   ts.forEachChild(node, (child) =>
     visitSetup(checker, child, state, filters, logger)
@@ -68,6 +71,7 @@ export const visitRoutes = (
   filters: InspectorFilters,
   logger: InspectorLogger
 ) => {
+  addFunctions(node, checker, state, logger)
   addHTTPRoute(node, checker, state, filters, logger)
   addSchedule(node, checker, state, filters, logger)
   addQueueWorker(node, checker, state, filters, logger)
@@ -75,6 +79,9 @@ export const visitRoutes = (
   addMCPResource(node, checker, state, filters, logger)
   addMCPTool(node, checker, state, filters, logger)
   addMCPPrompt(node, checker, state, filters, logger)
+  addMiddleware(node, checker, state, logger)
+  addPermission(node, checker, state, logger)
+
   ts.forEachChild(node, (child) =>
     visitRoutes(checker, child, state, filters, logger)
   )