@pikku/inspector 0.9.2 → 0.9.4

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @pikku/inspector
 
+## 0.9.4
+
+### Patch Changes
+
+- 6059c87: refactor: move PikkuPermission to pikkuPermission and same for middleware for api consistency to to improve future features
+- 6db63bb: perf: changing http meta to a lookup map to reduce loops
+- Updated dependencies [6059c87]
+- Updated dependencies [6db63bb]
+- Updated dependencies [74f8634]
+- Updated dependencies [766fef1]
+  - @pikku/core@0.9.6
+
+## 0.9.3
+
+### Patch Changes
+
+- 9691aba: fix: add-functions should support both functions only and objects
+- 2ab0278: refactor: no longer import ALL functions, only the ones used by rpcs
+- 81005ba: feat: creating a smaller meta file for functions to reduce size
+- b3c2829: fix (using ai): generating custom types broke imports.. this fixes it, but needs more robust training
+- Updated dependencies [9691aba]
+- Updated dependencies [2ab0278]
+- Updated dependencies [81005ba]
+  - @pikku/core@0.9.3
+
 ## 0.9.2
 
 ### Patch Changes

package/dist/add-functions.d.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
-import { InspectorState, InspectorFilters, InspectorLogger } from './types.js';
+import { InspectorLogger, InspectorState } from './types.js';
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export declare function addFunctions(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger): void;
+export declare function addFunctions(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, logger: InspectorLogger): void;

package/dist/add-functions.js

@@ -60,6 +60,20 @@ const resolveTypeImports = (type, resolvedTypes, isCustom) => {
                 typeRef.typeArguments?.forEach(visitType);
             }
         }
+        // Always traverse type arguments for thorough type collection
+        if (currentType.aliasTypeArguments) {
+            currentType.aliasTypeArguments.forEach(visitType);
+        }
+        // Always handle intersections and unions
+        if (currentType.isUnionOrIntersection()) {
+            currentType.types.forEach(visitType);
+        }
+        // Always handle object types with type arguments
+        if (currentType.flags & ts.TypeFlags.Object &&
+            currentType.objectFlags & ts.ObjectFlags.Reference) {
+            const typeRef = currentType;
+            typeRef.typeArguments?.forEach(visitType);
+        }
     };
     visitType(type);
     return types;
@@ -172,7 +186,7 @@ function unwrapPromise(checker, type) {
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export function addFunctions(node, checker, state, filters, logger) {
+export function addFunctions(node, checker, state, logger) {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args, typeArguments } = node;
@@ -198,21 +212,23 @@ export function addFunctions(node, checker, state, filters, logger) {
     // determine the actual handler expression:
     // either the `func` prop or the first argument directly
     let handlerNode = args[0];
+    let isDirectFunction = true; // Default to direct function format
     if (ts.isObjectLiteralExpression(handlerNode)) {
+        isDirectFunction = false; // This is object format with func property
         tags = getPropertyValue(handlerNode, 'tags') || undefined;
         expose = getPropertyValue(handlerNode, 'expose');
         docs = getPropertyValue(handlerNode, 'docs');
         const fnProp = getPropertyAssignmentInitializer(handlerNode, 'func', true, checker);
         if (!fnProp ||
             (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
-            console.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
+            logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
             return;
         }
         handlerNode = fnProp;
     }
     if (!ts.isArrowFunction(handlerNode) &&
         !ts.isFunctionExpression(handlerNode)) {
-        console.error(`• Handler for ${name} is not a function.`);
+        logger.error(`• Handler for ${name} is not a function.`);
         return;
     }
     const services = {
@@ -244,7 +260,7 @@ export function addFunctions(node, checker, state, filters, logger) {
     // --- Input Extraction ---
     let { names: inputNames } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
     // if (inputTypes.length === 0) {
-    //   console.debug(
+    //   logger.debug(
     //     `\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`
     //   )
     // }
@@ -262,38 +278,42 @@ export function addFunctions(node, checker, state, filters, logger) {
         }
     }
     if (inputNames.length > 1) {
-        console.warn('More than one input type detected, only the first one will be used as a schema.');
+        logger.warn('More than one input type detected, only the first one will be used as a schema.');
     }
     state.functions.meta[pikkuFuncName] = {
         pikkuFuncName,
         name,
         services,
-        schemaName: inputNames[0] ?? null,
+        inputSchemaName: inputNames[0] ?? null,
+        outputSchemaName: outputNames[0] ?? null,
         inputs: inputNames.filter((n) => n !== 'void') ?? null,
         outputs: outputNames.filter((n) => n !== 'void') ?? null,
-        expose,
-        tags,
-        docs,
+        expose: expose || undefined,
+        tags: tags || undefined,
+        docs: docs || undefined,
+        isDirectFunction,
     };
-    if (explicitName || exportedName) {
+    if (exportedName || explicitName) {
         if (!exportedName) {
-            console.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
+            logger.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
             return;
         }
-        if (state.rpc.meta[name]) {
-            console.error(`• Function name '${name}' already exists, skipping.`);
-            return;
+        if (expose) {
+            state.rpc.exposedMeta[name] = pikkuFuncName;
+            state.rpc.exposedFiles.set(name, {
+                path: node.getSourceFile().fileName,
+                exportedName,
+            });
+        }
+        // We add it to internal meta to allow autocomplete for everything
+        state.rpc.internalMeta[name] = pikkuFuncName;
+        // But we only import the actual function if it's actually invoked to keep
+        // bundle size down
+        if (state.rpc.invokedFunctions.has(pikkuFuncName)) {
+            state.rpc.internalFiles.set(name, {
+                path: node.getSourceFile().fileName,
+                exportedName,
+            });
         }
-        state.rpc.meta[name] = {
-            pikkuFuncName,
-            exposed: false,
-        };
-        state.functions.files.set(name, {
-            path: node.getSourceFile().fileName,
-            exportedName,
-        });
-    }
-    else {
-        console.log(`• Function name '${name}' not exported, skipping.`);
     }
 }

package/dist/add-http-route.js

@@ -67,7 +67,7 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
     const inputTypes = getInputTypes(state.http.metaInputTypes, method, input, query, params);
     // --- record route ---
     state.http.files.add(node.getSourceFile().fileName);
-    state.http.meta.push({
+    state.http.meta[method][route] = {
         pikkuFuncName: funcName,
         route,
         method: method,
@@ -76,5 +76,5 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
         inputTypes,
         docs,
         tags,
-    });
+    };
 };

package/dist/add-middleware.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { InspectorLogger, InspectorState } from './types.js';
+/**
+ * Inspect pikkuMiddleware calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export declare function addMiddleware(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, logger: InspectorLogger): void;

package/dist/add-middleware.js

@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+import { extractFunctionName, extractServicesFromFunction } from './utils.js';
+/**
+ * Inspect pikkuMiddleware calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export function addMiddleware(node, checker, state, logger) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    // only handle calls like pikkuMiddleware(...)
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    if (expression.text !== 'pikkuMiddleware') {
+        return;
+    }
+    const handlerNode = args[0];
+    if (!handlerNode)
+        return;
+    if (!ts.isArrowFunction(handlerNode) &&
+        !ts.isFunctionExpression(handlerNode)) {
+        logger.error(`• Handler for pikkuMiddleware is not a function.`);
+        return;
+    }
+    const services = extractServicesFromFunction(handlerNode);
+    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+    state.middleware.meta[pikkuFuncName] = {
+        services,
+        sourceFile: node.getSourceFile().fileName,
+        position: node.getStart(),
+        exportedName,
+    };
+    logger.debug(`• Found middleware with services: ${services.services.join(', ')}`);
+}

package/dist/add-permission.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { InspectorLogger, InspectorState } from './types.js';
+/**
+ * Inspect pikkuPermission calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export declare function addPermission(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, logger: InspectorLogger): void;

package/dist/add-permission.js

@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+import { extractFunctionName, extractServicesFromFunction } from './utils.js';
+/**
+ * Inspect pikkuPermission calls and extract first-arg destructuring
+ * for tree shaking optimization.
+ */
+export function addPermission(node, checker, state, logger) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    // only handle calls like pikkuPermission(...)
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    if (expression.text !== 'pikkuPermission') {
+        return;
+    }
+    const handlerNode = args[0];
+    if (!handlerNode)
+        return;
+    if (!ts.isArrowFunction(handlerNode) &&
+        !ts.isFunctionExpression(handlerNode)) {
+        logger.error(`• Handler for pikkuPermission is not a function.`);
+        return;
+    }
+    const services = extractServicesFromFunction(handlerNode);
+    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+    state.permissions.meta[pikkuFuncName] = {
+        services,
+        sourceFile: node.getSourceFile().fileName,
+        position: node.getStart(),
+        exportedName,
+    };
+    logger.debug(`• Found permission with services: ${services.services.join(', ')}`);
+}

package/dist/add-rpc-invocations.d.ts

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+import { InspectorState, InspectorLogger } from './types.js';
+/**
+ * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ */
+export declare function addRPCInvocations(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add-rpc-invocations.js

@@ -0,0 +1,36 @@
+import * as ts from 'typescript';
+/**
+ * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ */
+export function addRPCInvocations(node, state, logger) {
+    // Look for property access expressions: rpc.invoke
+    if (ts.isPropertyAccessExpression(node)) {
+        const { expression, name } = node;
+        // Check if this is accessing 'invoke' property
+        if (name.text === 'invoke') {
+            // Check if the object is 'rpc' (or a variable containing rpc)
+            if (ts.isIdentifier(expression) && expression.text === 'rpc') {
+                // This is rpc.invoke - now we need to find the parent call expression
+                const parent = node.parent;
+                if (ts.isCallExpression(parent) && parent.expression === node) {
+                    // This is rpc.invoke('function-name')
+                    const [firstArg] = parent.arguments;
+                    if (firstArg) {
+                        // Extract the function name from string literal
+                        if (ts.isStringLiteral(firstArg)) {
+                            const functionName = firstArg.text;
+                            logger.debug(`• Found RPC invocation: ${functionName}`);
+                            state.rpc.invokedFunctions.add(functionName);
+                        }
+                        // Handle template literals like `function-${name}`
+                        else if (ts.isTemplateExpression(firstArg) ||
+                            ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                            logger.warn(`• Found dynamic RPC invocation: ${firstArg.getText()}`);
+                            logger.warn(`\tYou can only use string literals for RPC function names, with ' or " and not \``);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/inspector.js

@@ -21,11 +21,18 @@ export const inspect = (logger, routeFiles, filters) => {
         functions: {
             typesMap: new TypesMap(),
             meta: {},
-            files: new Map(),
         },
         http: {
             metaInputTypes: new Map(),
-            meta: [],
+            meta: {
+                get: {},
+                post: {},
+                put: {},
+                delete: {},
+                head: {},
+                patch: {},
+                options: {},
+            },
             files: new Set(),
         },
         channels: {
@@ -41,7 +48,11 @@ export const inspect = (logger, routeFiles, filters) => {
             files: new Set(),
         },
         rpc: {
-            meta: {},
+            internalMeta: {},
+            internalFiles: new Map(),
+            exposedMeta: {},
+            exposedFiles: new Map(),
+            invokedFunctions: new Set(),
         },
         mcpEndpoints: {
             resourcesMeta: {},
@@ -49,6 +60,12 @@ export const inspect = (logger, routeFiles, filters) => {
             promptsMeta: {},
             files: new Set(),
         },
+        middleware: {
+            meta: {},
+        },
+        permissions: {
+            meta: {},
+        },
     };
     // First sweep: add all functions
     for (const sourceFile of sourceFiles) {

package/dist/types.d.ts

@@ -4,8 +4,7 @@ import { ScheduledTasksMeta } from '@pikku/core/scheduler';
 import { queueWorkersMeta } from '@pikku/core/queue';
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core';
 import { TypesMap } from './types-map.js';
-import { FunctionsMeta } from '@pikku/core';
-import { RPCMeta } from '@pikku/core/rpc';
+import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core';
 export type PathToNameAndType = Map<string, {
     variable: string;
     type: string | null;
@@ -23,16 +22,28 @@ export interface InspectorHTTPState {
 }
 export interface InspectorFunctionState {
     typesMap: TypesMap;
-    files: Map<string, {
-        path: string;
-        exportedName: string;
-    }>;
     meta: FunctionsMeta;
 }
 export interface InspectorChannelState {
     meta: ChannelsMeta;
     files: Set<string>;
 }
+export interface InspectorMiddlewareState {
+    meta: Record<string, {
+        services: FunctionServicesMeta;
+        sourceFile: string;
+        position: number;
+        exportedName: string | null;
+    }>;
+}
+export interface InspectorPermissionState {
+    meta: Record<string, {
+        services: FunctionServicesMeta;
+        sourceFile: string;
+        position: number;
+        exportedName: string | null;
+    }>;
+}
 export type InspectorFilters = {
     tags?: string[];
     types?: string[];
@@ -63,7 +74,17 @@ export interface InspectorState {
         files: Set<string>;
     };
     rpc: {
-        meta: Record<string, RPCMeta>;
+        internalMeta: Record<string, string>;
+        internalFiles: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
+        exposedMeta: Record<string, string>;
+        exposedFiles: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
+        invokedFunctions: Set<string>;
     };
     mcpEndpoints: {
         resourcesMeta: MCPResourceMeta;
@@ -71,4 +92,6 @@ export interface InspectorState {
         promptsMeta: MCPPromptMeta;
         files: Set<string>;
     };
+    middleware: InspectorMiddlewareState;
+    permissions: InspectorPermissionState;
 }

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { InspectorFilters, InspectorLogger } from './types.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { PikkuWiringTypes, FunctionServicesMeta } from '@pikku/core';
 type ExtractedFunctionName = {
     pikkuFuncName: string;
     name: string;
@@ -32,4 +32,8 @@ export declare const matchesFilters: (filters: InspectorFilters, params: {
     name: string;
     filePath?: string;
 }, logger: InspectorLogger) => boolean;
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export declare function extractServicesFromFunction(handlerNode: ts.FunctionExpression | ts.ArrowFunction): FunctionServicesMeta;
 export {};

package/dist/utils.js

@@ -219,7 +219,7 @@ export function extractFunctionName(callExpr, checker) {
             const decls = resolvedSym.declarations ?? [];
             if (decls.length > 0) {
                 const decl = decls[0];
-                // Check if the declaration is a variable that uses pikkuSessionlessFunc
+                // Check if the declaration is a variable that uses a pikkuFun
                 if (ts.isVariableDeclaration(decl) && decl.initializer) {
                     if (ts.isCallExpression(decl.initializer) &&
                         ts.isIdentifier(decl.initializer.expression) &&
@@ -240,6 +240,8 @@ export function extractFunctionName(callExpr, checker) {
                                 isNamedExport(decl) &&
                                 ts.isIdentifier(decl.name)) {
                                 result.exportedName = decl.name.text;
+                                // CRITICAL FIX: Use exported name as pikkuFuncName for consistency
+                                result.pikkuFuncName = decl.name.text;
                             }
                             else if (ts.isIdentifier(decl.name)) {
                                 // If not exported, still capture the variable name
@@ -566,6 +568,10 @@ export function extractFunctionName(callExpr, checker) {
     }
     // Apply name priority logic
     populateNameByPriority(result);
+    // CRITICAL FIX: If we have an exported name, use it as the pikkuFuncName for consistent lookup
+    if (result.exportedName && !result.explicitName) {
+        result.pikkuFuncName = result.exportedName;
+    }
     return result;
 }
 /**
@@ -705,3 +711,31 @@ export const matchesFilters = (filters, params, meta, logger) => {
     }
     return true;
 };
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export function extractServicesFromFunction(handlerNode) {
+    const services = {
+        optimized: true,
+        services: [],
+    };
+    const firstParam = handlerNode.parameters[0];
+    if (firstParam) {
+        if (ts.isObjectBindingPattern(firstParam.name)) {
+            for (const elem of firstParam.name.elements) {
+                const original = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : ts.isIdentifier(elem.name)
+                        ? elem.name.text
+                        : undefined;
+                if (original) {
+                    services.services.push(original);
+                }
+            }
+        }
+        else if (ts.isIdentifier(firstParam.name)) {
+            services.optimized = false;
+        }
+    }
+    return services;
+}

package/dist/visit.js

@@ -9,6 +9,9 @@ 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');
@@ -16,10 +19,11 @@ export const visitSetup = (checker, node, state, filters, logger) => {
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
     addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
-    addFunctions(node, checker, state, filters, logger);
+    addRPCInvocations(node, state, logger);
     ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters, logger));
 };
 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);
@@ -27,5 +31,7 @@ export const visitRoutes = (checker, node, 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));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -17,7 +17,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.9.2",
+    "@pikku/core": "^0.9.6",
     "path-to-regexp": "^8.2.0",
     "typescript": "^5.9"
   },