@pikku/inspector 0.10.1 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @pikku/inspector
 
+## 0.10.2
+
+### Patch Changes
+
+- 1967172: Update code generation to support channel middleware enhancements
+
+  **Code Generation Updates:**
+
+  - Update channel type serialization to include middleware support
+  - Improve WebSocket wrapper generation for middleware handling
+  - Update CLI channel client generation with better type support
+  - Enhance services and schema generation for channel configurations
+
+  **Inspector Updates:**
+
+  - Improve channel metadata extraction for middleware
+  - Better type analysis for channel lifecycle functions
+  - Enhanced post-processing for channel configurations
+
+- 753481a: Add bootstrap command, performance optimizations, and CLI improvements
+
+  **New Features:**
+
+  - Add `pikku bootstrap` command for type-only generation (~13.5% faster than `pikku all`)
+  - Add configurable `ignoreFiles` option to pikku.config.json with sensible defaults (_.gen.ts, _.test.ts, \*.spec.ts)
+  - Export pikkuCLIRender helper from serialize-cli-types.ts with JSDoc documentation
+
+  **Performance Improvements:**
+
+  - Add aggressive TypeScript compiler options (skipDefaultLibCheck, types: []) - ~37% faster TypeScript setup
+  - Add detailed performance timing to inspector phases (--logLevel=debug)
+  - Optimize file inspection with ignore patterns - ~10-20% faster overall
+
+  **Enhancements:**
+
+  - Fix --logLevel flag to properly apply log level to logger
+  - Update middleware logging to use structured log format
+  - Improve CLI renderers to consistently use destructured logger service
+  - Fix middleware file generation when middleware groups exist
+
+- 44d71a8: fix: fixing inspector ensuring pikkuConfig is set
+- Updated dependencies [ea652dc]
+- Updated dependencies [4349ec5]
+- Updated dependencies [44d71a8]
+  - @pikku/core@0.10.2
+
 ## 0.10.1
 
 ### Patch Changes

package/dist/add/add-channel.js

@@ -94,7 +94,15 @@ export function addMessagesRoutes(logger, obj, state, checker) {
             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)) {
                 // Get the symbol for the shorthand property
@@ -133,8 +141,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                         // 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;
                                         }
@@ -147,8 +163,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                     // 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;
                                     }
@@ -172,8 +196,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 const handlerName = pikkuFuncName;
                                                 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;
                                                 }
@@ -183,8 +215,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 const handlerName = pikkuFuncName;
                                                 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;
                                                 }
@@ -239,8 +279,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                             // Now use this handlerName to 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; // Skip the normal processing below
                             }
@@ -259,8 +307,17 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                 logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${handlerName}'`);
                 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,
             };
         }
     }
@@ -295,24 +352,21 @@ export const addChannel = (logger, node, checker, state, options) => {
     const docs = getPropertyValue(obj, 'docs');
     const tags = getPropertyTags(obj, 'Channel', route, logger);
     const query = getPropertyValue(obj, 'query');
-    const connect = getPropertyAssignmentInitializer(obj, 'onConnect', false, checker);
-    const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', false, checker);
+    const connect = getPropertyAssignmentInitializer(obj, 'onConnect', true, checker);
+    const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', true, checker);
     // default onMessage handler
     let message = null;
-    const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', false, checker);
+    const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', 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}'`);
-            throw new Error();
-        }
-        else {
-            message = {
-                pikkuFuncName: extractFunctionName(onMsgProp, checker, state.rootDir).pikkuFuncName,
-            };
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for onMessage handler '${pikkuFuncName}'`);
+            return;
         }
+        message = {
+            pikkuFuncName,
+        };
     }
     // nested message-routes
     const messageWirings = addMessagesRoutes(logger, obj, state, checker);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { inspect } from './inspector.js';
+export { inspect, getInitialInspectorState } from './inspector.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export type { TypesMap } from './types-map.js';
 export type * from './types.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { inspect } from './inspector.js';
+export { inspect, getInitialInspectorState } from './inspector.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';

package/dist/inspector.d.ts

@@ -1,2 +1,8 @@
 import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export declare function getInitialInspectorState(rootDir: string): InspectorState;
 export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => InspectorState;

package/dist/inspector.js

@@ -1,19 +1,17 @@
 import * as ts from 'typescript';
+import { performance } from 'perf_hooks';
 import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
 import { findCommonAncestor } from './utils/find-root-dir.js';
 import { aggregateRequiredServices } from './utils/post-process.js';
-export const inspect = (logger, routeFiles, options = {}) => {
-    const program = ts.createProgram(routeFiles, {
-        target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.CommonJS,
-    });
-    const checker = program.getTypeChecker();
-    const sourceFiles = program.getSourceFiles();
-    // Infer root directory from source files
-    const rootDir = findCommonAncestor(routeFiles);
-    const state = {
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export function getInitialInspectorState(rootDir) {
+    return {
         rootDir,
         singletonServicesTypeImportMap: new Map(),
         sessionServicesTypeImportMap: new Map(),
@@ -91,21 +89,57 @@ export const inspect = (logger, routeFiles, options = {}) => {
             usedFunctions: new Set(),
             usedMiddleware: new Set(),
             usedPermissions: new Set(),
+            allSingletonServices: [],
+            allSessionServices: [],
         },
     };
+}
+export const inspect = (logger, routeFiles, options = {}) => {
+    const startProgram = performance.now();
+    const program = ts.createProgram(routeFiles, {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.CommonJS,
+        skipLibCheck: true,
+        skipDefaultLibCheck: true,
+        moduleResolution: ts.ModuleResolutionKind.Node10,
+        types: [],
+        allowJs: false,
+        checkJs: false,
+    });
+    logger.debug(`Created program in ${(performance.now() - startProgram).toFixed(2)}ms`);
+    const startChecker = performance.now();
+    const checker = program.getTypeChecker();
+    logger.debug(`Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`);
+    const startSourceFiles = performance.now();
+    const sourceFiles = program.getSourceFiles();
+    logger.debug(`Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`);
+    // Infer root directory from source files
+    const rootDir = findCommonAncestor(routeFiles);
+    const state = getInitialInspectorState(rootDir);
     // First sweep: add all functions
+    const startSetup = performance.now();
     for (const sourceFile of sourceFiles) {
         ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
     }
-    // Second sweep: add all transports
-    for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
+    logger.debug(`Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`);
+    if (!options.setupOnly) {
+        // Second sweep: add all transports
+        const startRoutes = performance.now();
+        for (const sourceFile of sourceFiles) {
+            ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
+        }
+        logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`);
     }
     // Populate filesAndMethods
+    const startFilesAndMethods = performance.now();
     const { result, errors } = getFilesAndMethods(state, options.types);
     state.filesAndMethods = result;
     state.filesAndMethodsErrors = errors;
-    // Post-processing: Aggregate required services from wired functions/middleware/permissions
-    aggregateRequiredServices(state);
+    logger.debug(`Get files and methods completed in ${(performance.now() - startFilesAndMethods).toFixed(2)}ms`);
+    if (!options.setupOnly) {
+        const startAggregate = performance.now();
+        aggregateRequiredServices(state);
+        logger.debug(`Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`);
+    }
     return state;
 };

package/dist/types.d.ts

@@ -86,6 +86,7 @@ export type InspectorFilters = {
     httpMethods?: string[];
 };
 export type InspectorOptions = Partial<{
+    setupOnly: boolean;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
@@ -200,5 +201,7 @@ export interface InspectorState {
         usedFunctions: Set<string>;
         usedMiddleware: Set<string>;
         usedPermissions: Set<string>;
+        allSingletonServices: string[];
+        allSessionServices: string[];
     };
 }

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

@@ -165,6 +165,8 @@ export interface SerializableInspectorState {
         usedFunctions: string[];
         usedMiddleware: string[];
         usedPermissions: string[];
+        allSingletonServices: string[];
+        allSessionServices: string[];
     };
 }
 /**

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

@@ -80,6 +80,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,
         },
     };
 }
@@ -165,6 +167,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.js

@@ -22,17 +22,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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.10.2",
     "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,
     }
   }