@pikku/inspector 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # @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
+
+- 778267e: fix: fixing inspector ensuring pikkuConfig is set
+- Updated dependencies [778267e]
+  - @pikku/core@0.10.1
+
 ## 0.10.0
 
 This release includes significant improvements across the framework including tree-shaking support, middleware/permission factories, enhanced CLI functionality, improved TypeScript type safety, and comprehensive test strategies.

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/add/add-file-with-factory.js

@@ -1,10 +1,63 @@
 import * as ts from 'typescript';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
+// Mapping of wrapper function names to their corresponding types
+const wrapperFunctionMap = {
+    pikkuConfig: 'CreateConfig',
+    pikkuServices: 'CreateSingletonServices',
+    pikkuSessionServices: 'CreateSessionServices',
+};
 export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {
         const fileName = node.getSourceFile().fileName;
         const variableTypeNode = node.type;
         const variableName = node.name.getText();
+        // Check for wrapper function calls FIRST (e.g., pikkuConfig(...), pikkuServices(...))
+        // This handles both cases: with and without explicit type annotations
+        if (node.initializer && ts.isCallExpression(node.initializer)) {
+            const callExpression = node.initializer;
+            const expression = callExpression.expression;
+            if (ts.isIdentifier(expression)) {
+                const wrapperFunctionName = expression.text;
+                const inferredType = wrapperFunctionMap[wrapperFunctionName];
+                if (inferredType === expectedTypeName) {
+                    // Get the type declaration path from the wrapper function
+                    const typeSymbol = checker.getSymbolAtLocation(expression);
+                    let typeDeclarationPath = null;
+                    if (typeSymbol &&
+                        typeSymbol.declarations &&
+                        typeSymbol.declarations[0]) {
+                        const declaration = typeSymbol.declarations[0];
+                        const sourceFile = declaration.getSourceFile();
+                        typeDeclarationPath = sourceFile.fileName;
+                    }
+                    const variables = methods.get(fileName) || [];
+                    variables.push({
+                        variable: variableName,
+                        type: inferredType,
+                        typePath: typeDeclarationPath,
+                    });
+                    methods.set(fileName, variables);
+                    // Extract singleton services for CreateSessionServices factories
+                    if (expectedTypeName === 'CreateSessionServices' &&
+                        state &&
+                        callExpression.arguments.length > 0) {
+                        const firstArg = callExpression.arguments[0];
+                        let functionNode;
+                        if (ts.isArrowFunction(firstArg)) {
+                            functionNode = firstArg;
+                        }
+                        else if (ts.isFunctionExpression(firstArg)) {
+                            functionNode = firstArg;
+                        }
+                        if (functionNode) {
+                            const servicesMeta = extractServicesFromFunction(functionNode);
+                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        }
+                    }
+                    return; // Early return since we found a match
+                }
+            }
+        }
         if (variableTypeNode && ts.isTypeReferenceNode(variableTypeNode)) {
             const typeNameNode = variableTypeNode.typeName || null;
             let typeDeclarationPath = null;

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/get-files-and-methods.js

@@ -19,9 +19,9 @@ const getMetaTypes = (type, map, desiredType, errors) => {
     if (totalValues.length === 0) {
         const helpMessage = type === 'CoreConfig'
             ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
-                `export const createConfig: CreateConfig<Config> = async () => {\n` +
+                `export const createConfig = pikkuConfig(async () => {\n` +
                 `  return {}\n` +
-                `}\n\n` +
+                `})\n\n` +
                 `Possible issues:\n` +
                 `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
             : `No ${type} found`;

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.0",
+  "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.0",
+    "@pikku/core": "^0.10.2",
     "path-to-regexp": "^8.3.0",
     "typescript": "^5.9"
   },