@pikku/inspector 0.9.5 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pikku/inspector
 
+## 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.
+
+For complete details, see https://pikku.dev/changelogs/0_10_0.md
+
+## 0.9.6-next.0
+
+### Patch Changes
+
+- feat: running @pikku/cli using pikku
+- Updated dependencies
+  - @pikku/core@0.9.12-next.0
+
 ## 0.9.5
 
 ### Patch Changes

package/dist/add/add-channel.d.ts

@@ -0,0 +1,17 @@
+import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
+import type { ChannelMeta } from '@pikku/core/channel';
+import type { InspectorState, AddWiring } from '../types.js';
+/**
+ * Build out the nested message-routes by looking up each handler
+ * in state.functions.meta instead of re-inferring it here.
+ */
+export declare function addMessagesRoutes(logger: {
+    error: (msg: string) => void;
+    critical: (code: ErrorCode, msg: string) => void;
+}, obj: ts.ObjectLiteralExpression, state: InspectorState, checker: ts.TypeChecker): ChannelMeta['messageWirings'];
+/**
+ * Inspect addChannel calls, look up all handlers in state.functions.meta,
+ * and emit one entry into state.channels.meta.
+ */
+export declare const addChannel: AddWiring;

package/dist/{add-channel.js → add/add-channel.js}

@@ -1,10 +1,13 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
 /**
- * Safely get the “initializer” expression of a property-like AST node:
+ * Safely get the "initializer" expression of a property-like AST node:
  * - for `foo: expr`, returns `expr`
  * - for `{ foo }` shorthand, returns the identifier `foo`
  * - otherwise, returns undefined
@@ -22,7 +25,7 @@ function getInitializerOf(elem) {
  * Resolve a handler expression (Identifier, CallExpression, or { func })
  * into its underlying function name.
  */
-function getHandlerNameFromExpression(expr, checker) {
+function getHandlerNameFromExpression(expr, checker, rootDir) {
     // Handle direct identifier case (which includes shorthand properties)
     if (ts.isIdentifier(expr)) {
         const sym = checker.getSymbolAtLocation(expr);
@@ -41,31 +44,31 @@ function getHandlerNameFromExpression(expr, checker) {
                         ts.isArrowFunction(decl.initializer) ||
                         ts.isFunctionExpression(decl.initializer)) {
                         // Extract function name from the declaration's initializer
-                        const { pikkuFuncName } = extractFunctionName(decl.initializer, checker);
+                        const { pikkuFuncName } = extractFunctionName(decl.initializer, checker, rootDir);
                         return pikkuFuncName;
                     }
                 }
                 // For function declarations, use directly
                 else if (ts.isFunctionDeclaration(decl)) {
-                    const { pikkuFuncName } = extractFunctionName(decl, checker);
+                    const { pikkuFuncName } = extractFunctionName(decl, checker, rootDir);
                     return pikkuFuncName;
                 }
             }
         }
         // Fallback: try to extract directly from the identifier
-        const { pikkuFuncName } = extractFunctionName(expr, checker);
+        const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir);
         return pikkuFuncName;
     }
     // Handle call expressions
     if (ts.isCallExpression(expr)) {
-        const { pikkuFuncName } = extractFunctionName(expr, checker);
+        const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir);
         return pikkuFuncName;
     }
     // Handle object literals with 'func' property
     if (ts.isObjectLiteralExpression(expr)) {
         const fnProp = getPropertyAssignmentInitializer(expr, 'func', true, checker);
         if (fnProp) {
-            return getHandlerNameFromExpression(fnProp, checker);
+            return getHandlerNameFromExpression(fnProp, checker, rootDir);
         }
     }
     return null;
@@ -74,7 +77,7 @@ function getHandlerNameFromExpression(expr, checker) {
  * Build out the nested message-routes by looking up each handler
  * in state.functions.meta instead of re-inferring it here.
  */
-export function addMessagesRoutes(obj, state, checker) {
+export function addMessagesRoutes(logger, obj, state, checker) {
     const result = {};
     const onMsgRouteProp = getPropertyAssignmentInitializer(obj, 'onMessageWiring', true, checker);
     if (!onMsgRouteProp)
@@ -125,7 +128,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                     if (ts.isArrowFunction(importDecl.initializer) ||
                                         ts.isFunctionExpression(importDecl.initializer) ||
                                         ts.isCallExpression(importDecl.initializer)) {
-                                        const { pikkuFuncName } = extractFunctionName(importDecl.initializer, checker);
+                                        const { pikkuFuncName } = extractFunctionName(importDecl.initializer, checker, state.rootDir);
                                         const handlerName = pikkuFuncName;
                                         // Look up in the registry
                                         const fnMeta = state.functions.meta[handlerName];
@@ -139,7 +142,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                 }
                                 else if (ts.isFunctionDeclaration(importDecl)) {
                                     // Extract from the function declaration
-                                    const { pikkuFuncName } = extractFunctionName(importDecl, checker);
+                                    const { pikkuFuncName } = extractFunctionName(importDecl, checker, state.rootDir);
                                     const handlerName = pikkuFuncName;
                                     // Look up in the registry
                                     const fnMeta = state.functions.meta[handlerName];
@@ -165,7 +168,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                             const exportDecl = exportDecls[0];
                                             if (ts.isVariableDeclaration(exportDecl) &&
                                                 exportDecl.initializer) {
-                                                const { pikkuFuncName } = extractFunctionName(exportDecl.initializer, checker);
+                                                const { pikkuFuncName } = extractFunctionName(exportDecl.initializer, checker, state.rootDir);
                                                 const handlerName = pikkuFuncName;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
@@ -176,7 +179,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                                 }
                                             }
                                             else if (ts.isFunctionDeclaration(exportDecl)) {
-                                                const { pikkuFuncName } = extractFunctionName(exportDecl, checker);
+                                                const { pikkuFuncName } = extractFunctionName(exportDecl, checker, state.rootDir);
                                                 const handlerName = pikkuFuncName;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
@@ -202,7 +205,7 @@ export function addMessagesRoutes(obj, state, checker) {
                         if (possibleMatch) {
                             const fnMeta = state.functions.meta[possibleMatch];
                             if (!fnMeta) {
-                                console.error(`No function metadata found for handler '${possibleMatch}'`);
+                                logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${possibleMatch}'`);
                                 continue;
                             }
                             result[channelKey][routeKey] = {
@@ -231,7 +234,7 @@ export function addMessagesRoutes(obj, state, checker) {
                         // If we found the actual function, extract its name
                         if (actualFunction) {
                             // Extract the function name directly from the actual function
-                            const { pikkuFuncName } = extractFunctionName(actualFunction, checker);
+                            const { pikkuFuncName } = extractFunctionName(actualFunction, checker, state.rootDir);
                             const handlerName = pikkuFuncName;
                             // Now use this handlerName to look up in the registry
                             const fnMeta = state.functions.meta[handlerName];
@@ -246,14 +249,14 @@ export function addMessagesRoutes(obj, state, checker) {
                 }
             }
             // Normal processing for non-shorthand properties
-            const handlerName = getHandlerNameFromExpression(init, checker);
+            const handlerName = getHandlerNameFromExpression(init, checker, state.rootDir);
             if (!handlerName) {
-                console.error(`Could not resolve handler for message route '${routeKey}'`);
+                logger.error(`Could not resolve handler for message route '${routeKey}'`);
                 continue;
             }
             const fnMeta = state.functions.meta[handlerName];
             if (!fnMeta) {
-                console.error(`No function metadata found for handler '${handlerName}'`);
+                logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${handlerName}'`);
                 continue;
             }
             result[channelKey][routeKey] = {
@@ -267,7 +270,7 @@ export function addMessagesRoutes(obj, state, checker) {
  * Inspect addChannel calls, look up all handlers in state.functions.meta,
  * and emit one entry into state.channels.meta.
  */
-export function addChannel(node, checker, state, filters, logger) {
+export const addChannel = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
@@ -280,7 +283,7 @@ export function addChannel(node, checker, state, filters, logger) {
     const name = getPropertyValue(obj, 'name');
     const route = getPropertyValue(obj, 'route') ?? '';
     if (!name) {
-        console.error('Channel name is required');
+        logger.critical(ErrorCode.MISSING_CHANNEL_NAME, 'Channel name is required');
         return;
     }
     // path parameters
@@ -290,18 +293,16 @@ export function addChannel(node, checker, state, filters, logger) {
             .map((k) => k.name)
         : [];
     const docs = getPropertyValue(obj, 'docs');
-    const tags = getPropertyValue(obj, 'tags');
+    const tags = getPropertyTags(obj, 'Channel', route, logger);
     const query = getPropertyValue(obj, 'query');
-    const filePath = node.getSourceFile().fileName;
-    if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.channel, name, filePath }, logger))
-        return;
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', false, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', false, checker);
     // default onMessage handler
     let message = null;
     const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', false, checker);
     if (onMsgProp) {
-        const handlerName = onMsgProp && getHandlerNameFromExpression(onMsgProp, checker);
+        const handlerName = onMsgProp &&
+            getHandlerNameFromExpression(onMsgProp, checker, state.rootDir);
         const fnMeta = handlerName && state.functions.meta[handlerName];
         if (!fnMeta) {
             console.error(`No function metadata for onMessage handler '${handlerName}'`);
@@ -309,13 +310,35 @@ export function addChannel(node, checker, state, filters, logger) {
         }
         else {
             message = {
-                pikkuFuncName: extractFunctionName(onMsgProp, checker)
-                    .pikkuFuncName,
+                pikkuFuncName: extractFunctionName(onMsgProp, checker, state.rootDir).pikkuFuncName,
             };
         }
     }
     // nested message-routes
-    const messageWirings = addMessagesRoutes(obj, state, checker);
+    const messageWirings = addMessagesRoutes(logger, obj, state, checker);
+    // --- resolve middleware ---
+    const middleware = resolveMiddleware(state, obj, tags, checker);
+    // --- track used functions/middleware for service aggregation ---
+    // Track connect/disconnect/message handlers
+    if (connect) {
+        const connectFuncName = extractFunctionName(connect, checker, state.rootDir).pikkuFuncName;
+        state.serviceAggregation.usedFunctions.add(connectFuncName);
+    }
+    if (disconnect) {
+        const disconnectFuncName = extractFunctionName(disconnect, checker, state.rootDir).pikkuFuncName;
+        state.serviceAggregation.usedFunctions.add(disconnectFuncName);
+    }
+    if (message) {
+        state.serviceAggregation.usedFunctions.add(message.pikkuFuncName);
+    }
+    // Track message wiring handlers
+    for (const channelHandlers of Object.values(messageWirings)) {
+        for (const handler of Object.values(channelHandlers)) {
+            state.serviceAggregation.usedFunctions.add(handler.pikkuFuncName);
+        }
+    }
+    // Track middleware
+    extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
     // record into state
     state.channels.files.add(node.getSourceFile().fileName);
     state.channels.meta[name] = {
@@ -332,17 +355,20 @@ export function addChannel(node, checker, state, filters, logger) {
         //   params
         // ),
         connect: connect
-            ? { pikkuFuncName: extractFunctionName(connect, checker).pikkuFuncName }
+            ? {
+                pikkuFuncName: extractFunctionName(connect, checker, state.rootDir)
+                    .pikkuFuncName,
+            }
             : null,
         disconnect: disconnect
             ? {
-                pikkuFuncName: extractFunctionName(disconnect, checker)
-                    .pikkuFuncName,
+                pikkuFuncName: extractFunctionName(disconnect, checker, state.rootDir).pikkuFuncName,
             }
             : null,
         message,
         messageWirings,
         docs: docs ?? undefined,
         tags: tags ?? undefined,
+        middleware,
     };
-}
+};

package/dist/add/add-cli.d.ts

@@ -0,0 +1,9 @@
+import { AddWiring } from '../types.js';
+/**
+ * Adds CLI command metadata to the inspector state
+ */
+export declare const addCLI: AddWiring;
+/**
+ * Adds CLI renderer metadata to the inspector state
+ */
+export declare const addCLIRenderers: AddWiring;