@pikku/inspector 0.9.4 → 0.9.6-next.0

package/dist/utils/get-files-and-methods.js

@@ -0,0 +1,60 @@
+const getMetaTypes = (type, map, desiredType, errors) => {
+    if (desiredType) {
+        for (const [file, meta] of map.entries()) {
+            for (const { type: entryType, variable, typePath } of meta) {
+                if (entryType === desiredType) {
+                    if (entryType === null || typePath === null) {
+                        throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${desiredType} in ${file}`);
+                    }
+                    return { file, variable, type: entryType, typePath };
+                }
+            }
+        }
+        if (errors) {
+            errors.set(`No ${desiredType} found that extends ${type}`, map);
+        }
+        return;
+    }
+    const totalValues = Array.from(map.values()).flat();
+    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` +
+                `  return {}\n` +
+                `}\n\n` +
+                `Possible issues:\n` +
+                `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
+            : `No ${type} found`;
+        if (errors) {
+            errors.set(helpMessage, map);
+        }
+    }
+    else if (totalValues.length > 1) {
+        if (errors) {
+            errors.set(`More than one ${type} found`, map);
+        }
+    }
+    else {
+        const entry = Array.from(map.entries())[0];
+        if (entry) {
+            const [file, [{ type: entryType, variable, typePath }]] = entry;
+            if (entryType === null || typePath === null) {
+                throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${type} in ${file}`);
+            }
+            return { file, type: entryType, variable, typePath };
+        }
+    }
+    return;
+};
+export const getFilesAndMethods = ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = {}) => {
+    const errors = new Map();
+    const result = {
+        userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType, errors),
+        singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap, undefined, errors),
+        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap, undefined, errors),
+        pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType, errors),
+        singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType, errors),
+        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType, errors),
+    };
+    return { result, errors };
+};

package/dist/utils/middleware.d.ts

@@ -0,0 +1,39 @@
+import * as ts from 'typescript';
+import { MiddlewareMetadata } from '@pikku/core';
+import { InspectorState } from '../types.js';
+/**
+ * Extract middleware pikkuFuncNames from an array literal expression
+ * Resolves each identifier to its pikkuFuncName using extractFunctionName
+ * Also handles call expressions (like logCommandInfoAndTime({...}))
+ */
+export declare function extractMiddlewarePikkuNames(arrayNode: ts.Expression, checker: ts.TypeChecker): string[];
+/**
+ * Get middleware array from an object literal expression property
+ * Returns the initializer node for the 'middleware' property if it exists
+ */
+export declare function getMiddlewareNode(obj: ts.ObjectLiteralExpression): ts.Expression | undefined;
+/**
+ * Check if a route matches a pattern with wildcards
+ * Pattern can be exact match or use * as wildcard
+ * e.g., '/api/*' matches '/api/users', '/api/posts/123', etc.
+ */
+export declare function routeMatchesPattern(route: string, pattern: string): boolean;
+/**
+ * Resolve middleware for an HTTP wiring based on:
+ * 1. Global HTTP middleware (addd([...]))
+ * 2. Route-specific HTTP middleware (addHTTPMiddleware('/pattern', [...]))
+ * 3. Tag-based middleware (addMiddleware('tag', [...]))
+ * 4. Explicit wiring middleware (wireHTTP({ middleware: [...] }))
+ * Returns undefined if no middleware is found, otherwise returns array with at least one item
+ */
+export declare function resolveHTTPMiddleware(state: InspectorState, route: string, tags: string[] | undefined, explicitMiddlewareNode: ts.Expression | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;
+/**
+ * Convenience wrapper: Extract middleware node from object and resolve
+ * Use this in add-* files for cleaner code
+ */
+export declare function resolveMiddleware(state: InspectorState, obj: ts.ObjectLiteralExpression, tags: string[] | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;
+/**
+ * Convenience wrapper for HTTP: Extract middleware and resolve with HTTP-specific logic
+ * Use this in add-http-route.ts for cleaner code
+ */
+export declare function resolveHTTPMiddlewareFromObject(state: InspectorState, route: string, obj: ts.ObjectLiteralExpression, tags: string[] | undefined, checker: ts.TypeChecker): MiddlewareMetadata[] | undefined;

package/dist/utils/middleware.js

@@ -0,0 +1,157 @@
+import * as ts from 'typescript';
+import { extractFunctionName } from './extract-function-name.js';
+/**
+ * Extract middleware pikkuFuncNames from an array literal expression
+ * Resolves each identifier to its pikkuFuncName using extractFunctionName
+ * Also handles call expressions (like logCommandInfoAndTime({...}))
+ */
+export function extractMiddlewarePikkuNames(arrayNode, checker) {
+    if (!ts.isArrayLiteralExpression(arrayNode)) {
+        return [];
+    }
+    const names = [];
+    for (const element of arrayNode.elements) {
+        if (ts.isIdentifier(element)) {
+            // Resolve the identifier to its pikkuFuncName
+            const { pikkuFuncName } = extractFunctionName(element, checker);
+            names.push(pikkuFuncName);
+        }
+        else if (ts.isCallExpression(element)) {
+            // Handle call expressions like logCommandInfoAndTime({...})
+            // These create inline middleware, so we use the call expression itself as the name
+            const { pikkuFuncName } = extractFunctionName(element, checker);
+            names.push(pikkuFuncName);
+        }
+    }
+    return names;
+}
+/**
+ * Get middleware array from an object literal expression property
+ * Returns the initializer node for the 'middleware' property if it exists
+ */
+export function getMiddlewareNode(obj) {
+    const middlewareProp = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'middleware');
+    return middlewareProp?.initializer;
+}
+/**
+ * Check if a route matches a pattern with wildcards
+ * Pattern can be exact match or use * as wildcard
+ * e.g., '/api/*' matches '/api/users', '/api/posts/123', etc.
+ */
+export function routeMatchesPattern(route, pattern) {
+    if (route === pattern)
+        return true;
+    // Convert pattern to regex: replace * with .*
+    const regexPattern = pattern
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
+        .replace(/\*/g, '.*'); // Replace * with .*
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(route);
+}
+/**
+ * Resolve middleware for an HTTP wiring based on:
+ * 1. Global HTTP middleware (addd([...]))
+ * 2. Route-specific HTTP middleware (addHTTPMiddleware('/pattern', [...]))
+ * 3. Tag-based middleware (addMiddleware('tag', [...]))
+ * 4. Explicit wiring middleware (wireHTTP({ middleware: [...] }))
+ * Returns undefined if no middleware is found, otherwise returns array with at least one item
+ */
+export function resolveHTTPMiddleware(state, route, tags, explicitMiddlewareNode, checker) {
+    const resolved = [];
+    // 1. HTTP route middleware groups (includes '*' for global)
+    for (const [pattern, _groupMeta] of state.http.routeMiddleware.entries()) {
+        if (routeMatchesPattern(route, pattern)) {
+            // Just reference the group by route pattern
+            resolved.push({
+                type: 'http',
+                route: pattern,
+            });
+        }
+    }
+    // 2. Tag-based middleware groups
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            if (state.middleware.tagMiddleware.has(tag)) {
+                // Just reference the group by tag
+                resolved.push({
+                    type: 'tag',
+                    tag,
+                });
+            }
+        }
+    }
+    // 3. Explicit wire middleware (inline is OK here)
+    if (explicitMiddlewareNode) {
+        const middlewareNames = extractMiddlewarePikkuNames(explicitMiddlewareNode, checker);
+        for (const name of middlewareNames) {
+            const meta = state.middleware.meta[name];
+            resolved.push({
+                type: 'wire',
+                name,
+                inline: meta?.exportedName === null,
+            });
+        }
+    }
+    return resolved.length > 0 ? resolved : undefined;
+}
+/**
+ * Resolve tag-based and explicit middleware (common logic for wires and functions)
+ * 1. Tag-based middleware (addMiddleware('tag', [...]))
+ * 2. Explicit middleware (wireHTTP/pikkuFunc({ middleware: [...] }))
+ */
+function resolveTagAndExplicitMiddleware(state, tags, explicitMiddlewareNode, checker) {
+    const resolved = [];
+    // 1. Tag-based middleware groups
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            if (state.middleware.tagMiddleware.has(tag)) {
+                // Just reference the group by tag
+                resolved.push({
+                    type: 'tag',
+                    tag,
+                });
+            }
+        }
+    }
+    // 2. Explicit middleware (inline is OK here - used directly in wire/function)
+    if (explicitMiddlewareNode) {
+        const middlewareNames = extractMiddlewarePikkuNames(explicitMiddlewareNode, checker);
+        for (const name of middlewareNames) {
+            const meta = state.middleware.meta[name];
+            resolved.push({
+                type: 'wire',
+                name,
+                inline: meta?.exportedName === null,
+            });
+        }
+    }
+    return resolved;
+}
+/**
+ * Resolve middleware for a function based on:
+ * 1. Tag-based middleware (addMiddleware('tag', [...]))
+ * 2. Explicit function middleware (pikkuFunc({ middleware: [...] }))
+ * Returns undefined if no middleware is found, otherwise returns array with at least one item
+ */
+function resolveFunctionMiddlewareInternal(state, tags, explicitMiddlewareNode, checker) {
+    const resolved = resolveTagAndExplicitMiddleware(state, tags, explicitMiddlewareNode, checker);
+    return resolved.length > 0 ? resolved : undefined;
+}
+/**
+ * Convenience wrapper: Extract middleware node from object and resolve
+ * Use this in add-* files for cleaner code
+ */
+export function resolveMiddleware(state, obj, tags, checker) {
+    const explicitMiddlewareNode = getMiddlewareNode(obj);
+    return resolveFunctionMiddlewareInternal(state, tags, explicitMiddlewareNode, checker);
+}
+/**
+ * Convenience wrapper for HTTP: Extract middleware and resolve with HTTP-specific logic
+ * Use this in add-http-route.ts for cleaner code
+ */
+export function resolveHTTPMiddlewareFromObject(state, route, obj, tags, checker) {
+    const explicitMiddlewareNode = getMiddlewareNode(obj);
+    return resolveHTTPMiddleware(state, route, tags, explicitMiddlewareNode, checker);
+}

package/dist/utils/type-utils.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+export declare const extractTypeKeys: (type: ts.Type) => string[];
+export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;

package/dist/utils/type-utils.js

@@ -0,0 +1,50 @@
+import * as ts from 'typescript';
+export const extractTypeKeys = (type) => {
+    return type.getProperties().map((symbol) => symbol.getName());
+};
+export function getPropertyAssignmentInitializer(obj, propName, followShorthand = false, checker) {
+    for (const prop of obj.properties) {
+        // ①  foo: () => {}
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop.initializer;
+        }
+        // ②  foo() { … }
+        if (ts.isMethodDeclaration(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop.name; // the method node *is* the function
+        }
+        // ③  { foo }  (shorthand)
+        if (followShorthand &&
+            ts.isShorthandPropertyAssignment(prop) &&
+            prop.name.text === propName) {
+            if (!checker)
+                return prop.name; // best effort without a checker
+            let sym = checker.getSymbolAtLocation(prop.name);
+            if (sym && sym.flags & ts.SymbolFlags.Alias) {
+                sym = checker.getAliasedSymbol(sym);
+            }
+            const decl = sym?.declarations?.[0];
+            // const foo = () => {}
+            if (decl &&
+                ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                (ts.isArrowFunction(decl.initializer) ||
+                    ts.isFunctionExpression(decl.initializer))) {
+                return decl.initializer;
+            }
+            // function foo() {}
+            if (decl &&
+                (ts.isFunctionDeclaration(decl) ||
+                    ts.isArrowFunction(decl) ||
+                    ts.isFunctionExpression(decl))) {
+                return decl;
+            }
+            // fallback – just give back the identifier
+            return prop.name;
+        }
+    }
+    return undefined;
+}

package/dist/visit.d.ts

@@ -1,4 +1,4 @@
 import * as ts from 'typescript';
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
-export declare const visitSetup: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;
-export declare const visitRoutes: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;
+import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+export declare const visitSetup: (logger: InspectorLogger, checker: ts.TypeChecker, node: ts.Node, state: InspectorState, options: InspectorOptions) => void;
+export declare const visitRoutes: (logger: InspectorLogger, checker: ts.TypeChecker, node: ts.Node, state: InspectorState, options: InspectorOptions) => void;

package/dist/visit.js

@@ -1,37 +1,40 @@
 import * as ts from 'typescript';
-import { addFileWithFactory } from './add-file-with-factory.js';
-import { addFileExtendsCoreType } from './add-file-extends-core-type.js';
-import { addHTTPRoute } from './add-http-route.js';
-import { addSchedule } from './add-schedule.js';
-import { addQueueWorker } from './add-queue-worker.js';
-import { addMCPResource } from './add-mcp-resource.js';
-import { addMCPTool } from './add-mcp-tool.js';
-import { addMCPPrompt } from './add-mcp-prompt.js';
-import { addFunctions } from './add-functions.js';
-import { addChannel } from './add-channel.js';
-import { addRPCInvocations } from './add-rpc-invocations.js';
-import { addMiddleware } from './add-middleware.js';
-import { addPermission } from './add-permission.js';
-export const visitSetup = (checker, node, state, filters, logger) => {
-    addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices');
-    addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices');
-    addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession');
+import { addFileWithFactory } from './add/add-file-with-factory.js';
+import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
+import { addHTTPRoute } from './add/add-http-route.js';
+import { addSchedule } from './add/add-schedule.js';
+import { addQueueWorker } from './add/add-queue-worker.js';
+import { addMCPResource } from './add/add-mcp-resource.js';
+import { addMCPTool } from './add/add-mcp-tool.js';
+import { addMCPPrompt } from './add/add-mcp-prompt.js';
+import { addFunctions } from './add/add-functions.js';
+import { addChannel } from './add/add-channel.js';
+import { addRPCInvocations } from './add/add-rpc-invocations.js';
+import { addMiddleware } from './add/add-middleware.js';
+import { addPermission } from './add/add-permission.js';
+import { addCLI } from './add/add-cli.js';
+export const visitSetup = (logger, checker, node, state, options) => {
+    addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
+    addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices', state);
+    addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession', state);
+    addFileExtendsCoreType(node, checker, state.configTypeImportMap, 'CoreConfig', state);
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
     addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addRPCInvocations(node, state, logger);
-    ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters, logger));
+    addMiddleware(logger, node, checker, state, options);
+    addPermission(logger, node, checker, state, options);
+    ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));
 };
-export const visitRoutes = (checker, node, state, filters, logger) => {
-    addFunctions(node, checker, state, logger);
-    addHTTPRoute(node, checker, state, filters, logger);
-    addSchedule(node, checker, state, filters, logger);
-    addQueueWorker(node, checker, state, filters, logger);
-    addChannel(node, checker, state, filters, logger);
-    addMCPResource(node, checker, state, filters, logger);
-    addMCPTool(node, checker, state, filters, logger);
-    addMCPPrompt(node, checker, state, filters, logger);
-    addMiddleware(node, checker, state, logger);
-    addPermission(node, checker, state, logger);
-    ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters, logger));
+export const visitRoutes = (logger, checker, node, state, options) => {
+    addFunctions(logger, node, checker, state, options);
+    addHTTPRoute(logger, node, checker, state, options);
+    addSchedule(logger, node, checker, state, options);
+    addQueueWorker(logger, node, checker, state, options);
+    addChannel(logger, node, checker, state, options);
+    addCLI(logger, node, checker, state, options);
+    addMCPResource(logger, node, checker, state, options);
+    addMCPTool(logger, node, checker, state, options);
+    addMCPPrompt(logger, node, checker, state, options);
+    ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, options));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.9.4",
+  "version": "0.9.6-next.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -8,8 +8,7 @@
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc",
-    "build:esm": "tsc -b",
-    "build": "yarn build:esm",
+    "build": "tsc -b",
     "ncu": "npx npm-check-updates -x '/.*glob.*/'",
     "release": "yarn build && npm test",
     "test": "bash run-tests.sh",
@@ -17,7 +16,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.9.6",
+    "@pikku/core": "^0.9.12-next.0",
     "path-to-regexp": "^8.2.0",
     "typescript": "^5.9"
   },

package/run-tests.sh

@@ -46,7 +46,7 @@ if [ "$watch_mode" = true ]; then
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
 fi
 
 # Execute the node command with the expanded list of files

package/src/{add-channel.ts → add/add-channel.ts}

@@ -1,21 +1,16 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
+import { getPropertyValue } from '../utils/get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
 import { PikkuDocs, 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 { matchesFilters } from '../utils/filter-utils.js'
 import type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
-import type {
-  InspectorFilters,
-  InspectorState,
-  InspectorLogger,
-} from './types.js'
+import type { InspectorState, AddWiring } from '../types.js'
+import { resolveMiddleware } from '../utils/middleware.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
@@ -363,13 +358,14 @@ export function addMessagesRoutes(
  * Inspect addChannel calls, look up all handlers in state.functions.meta,
  * and emit one entry into state.channels.meta.
  */
-export function addChannel(
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
-) {
+export const addChannel: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  options
+) => {
+  const filters = options.filters || {}
   if (!ts.isCallExpression(node)) return
   const { expression, arguments: args } = node
   if (!ts.isIdentifier(expression) || expression.text !== 'wireChannel') return
@@ -450,6 +446,9 @@ export function addChannel(
   // nested message-routes
   const messageWirings = addMessagesRoutes(obj, state, checker)
 
+  // --- resolve middleware ---
+  const middleware = resolveMiddleware(state, obj, tags, checker)
+
   // record into state
   state.channels.files.add(node.getSourceFile().fileName)
   state.channels.meta[name] = {
@@ -478,5 +477,6 @@ export function addChannel(
     messageWirings,
     docs: docs ?? undefined,
     tags: tags ?? undefined,
+    middleware,
   }
 }