@pikku/inspector 0.11.2 → 0.12.1

package/src/add/add-channel.ts

@@ -5,12 +5,20 @@ import {
   getCommonWireMetaData,
 } from '../utils/get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
-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 type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
 import type { InspectorState, AddWiring } from '../types.js'
-import { resolveMiddleware } from '../utils/middleware.js'
+import {
+  resolveMiddleware,
+  resolveChannelMiddleware,
+} from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
+import { resolveIdentifier } from '../utils/resolve-identifier.js'
+import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 
 /**
  * Safely get the "initializer" expression of a property-like AST node:
@@ -61,31 +69,31 @@ function getHandlerNameFromExpression(
             ts.isFunctionExpression(decl.initializer)
           ) {
             // Extract function name from the declaration's initializer
-            const { pikkuFuncName } = extractFunctionName(
+            const { pikkuFuncId } = extractFunctionName(
               decl.initializer,
               checker,
               rootDir
             )
-            return pikkuFuncName
+            return pikkuFuncId
           }
         }
         // For function declarations, use directly
         else if (ts.isFunctionDeclaration(decl)) {
-          const { pikkuFuncName } = extractFunctionName(decl, checker, rootDir)
-          return pikkuFuncName
+          const { pikkuFuncId } = extractFunctionName(decl, checker, rootDir)
+          return pikkuFuncId
         }
       }
     }
 
     // Fallback: try to extract directly from the identifier
-    const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir)
-    return pikkuFuncName
+    const { pikkuFuncId } = extractFunctionName(expr, checker, rootDir)
+    return pikkuFuncId
   }
 
   // Handle call expressions
   if (ts.isCallExpression(expr)) {
-    const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir)
-    return pikkuFuncName
+    const { pikkuFuncId } = extractFunctionName(expr, checker, rootDir)
+    return pikkuFuncId
   }
 
   // Handle object literals with 'func' property
@@ -125,8 +133,20 @@ export function addMessagesRoutes(
     return result
 
   for (const chanElem of onMsgRouteProp.properties) {
-    const chanInit = getInitializerOf(chanElem)
-    if (!chanInit || !ts.isObjectLiteralExpression(chanInit)) continue
+    let chanInit = getInitializerOf(chanElem)
+    if (!chanInit) continue
+
+    // If the value is an identifier, resolve it (handles defineChannelRoutes)
+    if (ts.isIdentifier(chanInit)) {
+      const resolved = resolveIdentifier(chanInit, checker, [
+        'defineChannelRoutes',
+      ])
+      if (resolved && ts.isObjectLiteralExpression(resolved)) {
+        chanInit = resolved
+      }
+    }
+
+    if (!ts.isObjectLiteralExpression(chanInit)) continue
 
     const channelKey = chanElem.name!.getText()
     result[channelKey] = {}
@@ -193,12 +213,12 @@ export function addMessagesRoutes(
                     ts.isFunctionExpression(importDecl.initializer) ||
                     ts.isCallExpression(importDecl.initializer)
                   ) {
-                    const { pikkuFuncName } = extractFunctionName(
+                    const { pikkuFuncId } = extractFunctionName(
                       importDecl.initializer,
                       checker,
                       state.rootDir
                     )
-                    const handlerName = pikkuFuncName
+                    const handlerName = pikkuFuncId
 
                     // Look up in the registry
                     const fnMeta = state.functions.meta[handlerName]
@@ -217,7 +237,7 @@ export function addMessagesRoutes(
                         : undefined
 
                       result[channelKey]![routeKey] = {
-                        pikkuFuncName: handlerName,
+                        pikkuFuncId: handlerName,
                         middleware: routeMiddleware,
                       }
                       continue
@@ -225,12 +245,12 @@ export function addMessagesRoutes(
                   }
                 } else if (ts.isFunctionDeclaration(importDecl)) {
                   // Extract from the function declaration
-                  const { pikkuFuncName } = extractFunctionName(
+                  const { pikkuFuncId } = extractFunctionName(
                     importDecl,
                     checker,
                     state.rootDir
                   )
-                  const handlerName = pikkuFuncName
+                  const handlerName = pikkuFuncId
 
                   // Look up in the registry
                   const fnMeta = state.functions.meta[handlerName]
@@ -249,7 +269,7 @@ export function addMessagesRoutes(
                       : undefined
 
                     result[channelKey]![routeKey] = {
-                      pikkuFuncName: handlerName,
+                      pikkuFuncId: handlerName,
                       middleware: routeMiddleware,
                     }
                     continue
@@ -275,12 +295,12 @@ export function addMessagesRoutes(
                         ts.isVariableDeclaration(exportDecl) &&
                         exportDecl.initializer
                       ) {
-                        const { pikkuFuncName } = extractFunctionName(
+                        const { pikkuFuncId } = extractFunctionName(
                           exportDecl.initializer,
                           checker,
                           state.rootDir
                         )
-                        const handlerName = pikkuFuncName
+                        const handlerName = pikkuFuncId
 
                         const fnMeta = state.functions.meta[handlerName]
                         if (fnMeta) {
@@ -300,18 +320,18 @@ export function addMessagesRoutes(
                             : undefined
 
                           result[channelKey]![routeKey] = {
-                            pikkuFuncName: handlerName,
+                            pikkuFuncId: handlerName,
                             middleware: routeMiddleware,
                           }
                           continue
                         }
                       } else if (ts.isFunctionDeclaration(exportDecl)) {
-                        const { pikkuFuncName } = extractFunctionName(
+                        const { pikkuFuncId } = extractFunctionName(
                           exportDecl,
                           checker,
                           state.rootDir
                         )
-                        const handlerName = pikkuFuncName
+                        const handlerName = pikkuFuncId
 
                         const fnMeta = state.functions.meta[handlerName]
                         if (fnMeta) {
@@ -331,7 +351,7 @@ export function addMessagesRoutes(
                             : undefined
 
                           result[channelKey]![routeKey] = {
-                            pikkuFuncName: handlerName,
+                            pikkuFuncId: handlerName,
                             middleware: routeMiddleware,
                           }
                           continue
@@ -365,7 +385,7 @@ export function addMessagesRoutes(
                 continue
               }
               result[channelKey]![routeKey] = {
-                pikkuFuncName: possibleMatch,
+                pikkuFuncId: possibleMatch,
               }
               continue
             }
@@ -392,12 +412,12 @@ export function addMessagesRoutes(
             // If we found the actual function, extract its name
             if (actualFunction) {
               // Extract the function name directly from the actual function
-              const { pikkuFuncName } = extractFunctionName(
+              const { pikkuFuncId } = extractFunctionName(
                 actualFunction,
                 checker,
                 state.rootDir
               )
-              const handlerName = pikkuFuncName
+              const handlerName = pikkuFuncId
 
               // Now use this handlerName to look up in the registry
               const fnMeta = state.functions.meta[handlerName]
@@ -417,7 +437,7 @@ export function addMessagesRoutes(
                   : undefined
 
                 result[channelKey]![routeKey] = {
-                  pikkuFuncName: handlerName,
+                  pikkuFuncId: handlerName,
                   middleware: routeMiddleware,
                 }
                 continue // Skip the normal processing below
@@ -459,7 +479,7 @@ export function addMessagesRoutes(
         : undefined
 
       result[channelKey]![routeKey] = {
-        pikkuFuncName: handlerName,
+        pikkuFuncId: handlerName,
         middleware: routeMiddleware,
       }
     }
@@ -501,12 +521,11 @@ export const addChannel: AddWiring = (
         .map((k) => k.name)
     : []
 
-  const { tags, summary, description, errors } = getCommonWireMetaData(
-    obj,
-    'Channel',
-    name,
-    logger
-  )
+  const { disabled, tags, summary, description, errors } =
+    getCommonWireMetaData(obj, 'Channel', name, logger)
+
+  if (disabled) return
+
   const query = getPropertyValue(obj, 'query') as string[] | []
 
   const connect = getPropertyAssignmentInitializer(
@@ -532,21 +551,20 @@ export const addChannel: AddWiring = (
   )
 
   if (onMsgProp) {
-    const { pikkuFuncName } = extractFunctionName(
-      onMsgProp,
-      checker,
-      state.rootDir
-    )
-    const fnMeta = state.functions.meta[pikkuFuncName]
+    const extracted = extractFunctionName(onMsgProp, checker, state.rootDir)
+    const msgFuncId = extracted.pikkuFuncId.startsWith('__temp_')
+      ? makeContextBasedId('channel', name, 'message')
+      : extracted.pikkuFuncId
+    const fnMeta = state.functions.meta[msgFuncId]
     if (!fnMeta) {
       logger.critical(
         ErrorCode.FUNCTION_METADATA_NOT_FOUND,
-        `No function metadata found for onMessage handler '${pikkuFuncName}'`
+        `No function metadata found for onMessage handler '${msgFuncId}'`
       )
       return
     }
     message = {
-      pikkuFuncName,
+      pikkuFuncId: msgFuncId,
     }
   }
 
@@ -555,40 +573,65 @@ export const addChannel: AddWiring = (
 
   // --- resolve middleware ---
   const middleware = resolveMiddleware(state, obj, tags, checker)
+  const channelMiddleware = resolveChannelMiddleware(state, obj, tags, checker)
 
   // --- track used functions/middleware for service aggregation ---
   // Track connect/disconnect/message handlers
+  let connectFuncId: string | undefined
   if (connect) {
-    const connectFuncName = extractFunctionName(
-      connect,
-      checker,
-      state.rootDir
-    ).pikkuFuncName
-    state.serviceAggregation.usedFunctions.add(connectFuncName)
+    const extracted = extractFunctionName(connect, checker, state.rootDir)
+    connectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
+      ? makeContextBasedId('channel', name, 'connect')
+      : extracted.pikkuFuncId
+    state.serviceAggregation.usedFunctions.add(connectFuncId)
   }
+
+  let disconnectFuncId: string | undefined
   if (disconnect) {
-    const disconnectFuncName = extractFunctionName(
+    const extracted = extractFunctionName(
       disconnect as any,
       checker,
       state.rootDir
-    ).pikkuFuncName
-    state.serviceAggregation.usedFunctions.add(disconnectFuncName)
+    )
+    disconnectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
+      ? makeContextBasedId('channel', name, 'disconnect')
+      : extracted.pikkuFuncId
+    state.serviceAggregation.usedFunctions.add(disconnectFuncId)
   }
+
   if (message) {
-    state.serviceAggregation.usedFunctions.add(message.pikkuFuncName)
+    state.serviceAggregation.usedFunctions.add(message.pikkuFuncId)
   }
-  // Track message wiring handlers
+
   for (const channelHandlers of Object.values(messageWirings)) {
     for (const handler of Object.values(channelHandlers)) {
-      state.serviceAggregation.usedFunctions.add(handler.pikkuFuncName)
+      state.serviceAggregation.usedFunctions.add(handler.pikkuFuncId)
     }
   }
-  // Track middleware
   extractWireNames(middleware).forEach((name) =>
     state.serviceAggregation.usedMiddleware.add(name)
   )
 
-  // record into state
+  // --- validate auth/sessionless ---
+  const handlersToValidate = [
+    connectFuncId,
+    disconnectFuncId,
+    message?.pikkuFuncId,
+  ].filter(Boolean) as string[]
+  for (const funcId of handlersToValidate) {
+    if (
+      !validateAuthSessionless(
+        logger,
+        obj,
+        state,
+        funcId,
+        `Channel '${name}'`
+      )
+    ) {
+      return
+    }
+  }
+
   state.channels.files.add(node.getSourceFile().fileName)
   state.channels.meta[name] = {
     name,
@@ -596,28 +639,8 @@ export const addChannel: AddWiring = (
     input: null,
     params: params.length ? params : undefined,
     query: query?.length ? query : undefined,
-    // inputTypes: getInputTypes(
-    //   state.channels.metaInputTypes,
-    //   'get',
-    //   null, // TODO
-    //   query,
-    //   params
-    // ),
-    connect: connect
-      ? {
-          pikkuFuncName: extractFunctionName(connect, checker, state.rootDir)
-            .pikkuFuncName,
-        }
-      : null,
-    disconnect: disconnect
-      ? {
-          pikkuFuncName: extractFunctionName(
-            disconnect as any,
-            checker,
-            state.rootDir
-          ).pikkuFuncName,
-        }
-      : null,
+    connect: connectFuncId ? { pikkuFuncId: connectFuncId } : null,
+    disconnect: disconnectFuncId ? { pikkuFuncId: disconnectFuncId } : null,
     message,
     messageWirings,
     summary,
@@ -625,5 +648,6 @@ export const addChannel: AddWiring = (
     errors,
     tags: tags ?? undefined,
     middleware,
+    channelMiddleware,
   }
 }

package/src/add/add-cli.ts

@@ -1,15 +1,18 @@
-import ts, { TypeChecker } from 'typescript'
-import {
+import type { TypeChecker } from 'typescript'
+import ts from 'typescript'
+import type {
   AddWiring,
   InspectorLogger,
   InspectorOptions,
   InspectorState,
 } from '../types.js'
-import { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
+import type { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { getPropertyValue } from '../utils/get-property-value.js'
+import { resolveIdentifier } from '../utils/resolve-identifier.js'
+import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 
 // Track if we've warned about missing Config type to avoid duplicate warnings
 const configTypeWarningShown = new Set<string>()
@@ -106,6 +109,10 @@ function processCLIConfig(
     return null
   }
 
+  if (getPropertyValue(node, 'disabled') === true) {
+    return null
+  }
+
   // Second pass: process other properties with program tags available
   for (const prop of node.properties) {
     if (!ts.isPropertyAssignment(prop)) continue
@@ -152,7 +159,7 @@ function processCLIConfig(
           prop.initializer,
           typeChecker,
           inspectorState.rootDir
-        ).pikkuFuncName
+        ).pikkuFuncId
         break
     }
   }
@@ -177,6 +184,30 @@ function processCommands(
   let defaultCommandName: string | null = null
 
   for (const prop of node.properties) {
+    // Handle spread assignments: { ...externalCommands }
+    if (ts.isSpreadAssignment(prop)) {
+      let spreadTarget: ts.Node | undefined = prop.expression
+      if (ts.isIdentifier(prop.expression)) {
+        spreadTarget = resolveIdentifier(prop.expression, typeChecker, [
+          'defineCLICommands',
+        ])
+      }
+      if (spreadTarget && ts.isObjectLiteralExpression(spreadTarget)) {
+        const spreadCommands = processCommands(
+          logger,
+          spreadTarget,
+          sourceFile,
+          typeChecker,
+          programName,
+          inspectorState,
+          options,
+          programTags
+        )
+        Object.assign(commands, spreadCommands)
+      }
+      continue
+    }
+
     if (!ts.isPropertyAssignment(prop)) continue
 
     const commandName = getPropertyName(prop)
@@ -243,11 +274,11 @@ function processCommand(
     ts.isFunctionExpression(node)
   ) {
     return {
-      pikkuFuncName: extractFunctionName(
+      pikkuFuncId: extractFunctionName(
         node,
         typeChecker,
         inspectorState.rootDir
-      ).pikkuFuncName,
+      ).pikkuFuncId,
       positionals: [],
       options: {},
     }
@@ -285,13 +316,13 @@ function processCommand(
   }
 
   const meta: CLICommandMeta = {
-    pikkuFuncName: '',
+    pikkuFuncId: '',
     positionals: [],
     options: {},
   }
 
-  // First pass: extract pikkuFuncName and tags so we can use them when processing options/middleware
-  let pikkuFuncName: string | undefined
+  // First pass: extract pikkuFuncId and tags so we can use them when processing options/middleware
+  let pikkuFuncId: string | undefined
   let optionsNode: ts.ObjectLiteralExpression | undefined
   let tags: string[] | undefined
 
@@ -302,12 +333,12 @@ function processCommand(
     const propName = prop.name.text
 
     if (propName === 'func') {
-      pikkuFuncName = extractFunctionName(
+      pikkuFuncId = extractFunctionName(
         prop.initializer,
         typeChecker,
         inspectorState.rootDir
-      ).pikkuFuncName
-      meta.pikkuFuncName = pikkuFuncName
+      ).pikkuFuncId
+      meta.pikkuFuncId = pikkuFuncId
     } else if (
       propName === 'options' &&
       ts.isObjectLiteralExpression(prop.initializer)
@@ -367,11 +398,11 @@ function processCommand(
           prop.initializer,
           typeChecker,
           inspectorState.rootDir
-        ).pikkuFuncName
+        ).pikkuFuncId
         break
 
       case 'options':
-        // Process with pikkuFuncName from first pass
+        // Process with pikkuFuncId from first pass
         if (optionsNode) {
           meta.options = processOptions(
             logger,
@@ -379,7 +410,7 @@ function processCommand(
             typeChecker,
             inspectorState,
             options,
-            pikkuFuncName
+            pikkuFuncId
           )
         }
         break
@@ -424,12 +455,25 @@ function processCommand(
     }
   }
 
+  // --- validate auth/sessionless ---
+  if (
+    meta.pikkuFuncId &&
+    !validateAuthSessionless(
+      logger,
+      node,
+      inspectorState,
+      meta.pikkuFuncId,
+      `CLI command '${name}'`
+    )
+  ) {
+    return null
+  }
+
   // --- track used functions/middleware for service aggregation ---
-  inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncName)
+  inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncId)
   extractWireNames(meta.middleware).forEach((name) =>
     inspectorState.serviceAggregation.usedMiddleware.add(name)
   )
-  // Note: subcommands are tracked recursively when they're processed
 
   return meta
 }
@@ -443,7 +487,7 @@ function processOptions(
   typeChecker: TypeChecker,
   inspectorState: InspectorState,
   inspectorOptions: InspectorOptions,
-  pikkuFuncName?: string
+  pikkuFuncId?: string
 ): Record<string, any> {
   const options: Record<string, any> = {}
 
@@ -506,10 +550,10 @@ function processOptions(
       }
 
       // Extract enum values from the function input type if available
-      // Get the input type if we have a pikkuFuncName
+      // Get the input type if we have a pikkuFuncId
       let inputTypes: ts.Type[] | undefined
-      if (pikkuFuncName) {
-        inputTypes = inspectorState.typesLookup.get(pikkuFuncName)
+      if (pikkuFuncId) {
+        inputTypes = inspectorState.typesLookup.get(pikkuFuncId)
       }
 
       let derivedChoices: string[] | null = null
@@ -772,7 +816,7 @@ export const addCLIRenderers: AddWiring = (
   if (args.length === 0) return
 
   // Extract renderer name
-  const { pikkuFuncName, exportedName } = extractFunctionName(
+  const { pikkuFuncId, exportedName } = extractFunctionName(
     node,
     typeChecker,
     inspectorState.rootDir
@@ -808,8 +852,8 @@ export const addCLIRenderers: AddWiring = (
   }
 
   // Store renderer metadata
-  inspectorState.cli.meta.renderers[pikkuFuncName] = {
-    name: pikkuFuncName,
+  inspectorState.cli.meta.renderers[pikkuFuncId] = {
+    name: pikkuFuncId,
     exportedName: exportedName ?? undefined,
     services,
     filePath,

package/src/add/add-file-extends-core-type.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { PathToNameAndType, InspectorState } from '../types.js'
+import type { PathToNameAndType, InspectorState } from '../types.js'
 
 export const addFileExtendsCoreType = (
   node: ts.Node,

package/src/add/add-file-with-config.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript'
 import { doesTypeExtendsCore } from '../utils/does-type-extend-core-type.js'
-import { PathToNameAndType } from '../types.js'
+import type { PathToNameAndType } from '../types.js'
 
 export const addFileWithConfig = (
   node: ts.Node,

package/src/add/add-file-with-factory.ts

@@ -1,11 +1,13 @@
 import * as ts from 'typescript'
-import { PathToNameAndType, InspectorState } from '../types.js'
+import type { PathToNameAndType, InspectorState } from '../types.js'
 import { extractServicesFromFunction } from '../utils/extract-services.js'
 
 // Mapping of wrapper function names to their corresponding types
 const wrapperFunctionMap: Record<string, string> = {
   pikkuConfig: 'CreateConfig',
+  pikkuAddonConfig: 'CreateConfig',
   pikkuServices: 'CreateSingletonServices',
+  pikkuAddonServices: 'CreateSingletonServices',
   pikkuWireServices: 'CreateWireServices',
 }