@pikku/inspector 0.6.3 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @pikku/inspector
 
+## 0.7.0
+
+This has changed significantly. The inspector now finds all functions and then links them to events.
+
+This means we can now get:
+
+- RPCs out of the box
+- Schemas are per function, not event
+- Supports inline functions, external functions, anonymous functions
+
+## 0.6.4
+
+### Patch Changes
+
+- 60b2265: refactor: supporting request and response objects
+- Updated dependencies [60b2265]
+  - @pikku/core@0.6.22
+
 ## 0.6.3
 
 ### Patch Changes

package/dist/add-channel.d.ts

@@ -1,3 +1,13 @@
 import * as ts from 'typescript';
-import { InspectorFilters, InspectorState } from './types.js';
-export declare const addChannel: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;
+import type { ChannelMeta } from '@pikku/core/channel';
+import type { InspectorFilters, InspectorState } 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(obj: ts.ObjectLiteralExpression, state: InspectorState, checker: ts.TypeChecker): ChannelMeta['messageRoutes'];
+/**
+ * Inspect addChannel calls, look up all handlers in state.functions.meta,
+ * and emit one entry into state.channels.meta.
+ */
+export declare function addChannel(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters): void;

package/dist/add-channel.js

@@ -2,127 +2,355 @@ import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
 import { getInputTypes } from './add-http-route.js';
-import { getPropertyAssignment, getFunctionTypes, matchesFilters, } from './utils.js';
-const addMessagesRoutes = (obj, checker, typesMap) => {
-    const messageTypes = {};
-    // Find the onMessageRoute property
-    const messagesProperty = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
-        ts.isIdentifier(p.name) &&
-        p.name.text === 'onMessageRoute');
-    if (!messagesProperty || !ts.isPropertyAssignment(messagesProperty)) {
-        console.log('onMessageRoute property not found or is not a valid assignment.');
-        return {};
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+/**
+ * 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
+ */
+function getInitializerOf(elem) {
+    if (ts.isPropertyAssignment(elem)) {
+        return elem.initializer;
     }
-    const initializer = messagesProperty.initializer;
-    // Ensure initializer is an object literal expression
-    if (!ts.isObjectLiteralExpression(initializer)) {
-        console.log('onMessageRoute is not an object literal.');
-        return {};
+    if (ts.isShorthandPropertyAssignment(elem)) {
+        return elem.name;
     }
-    // Iterate over the first level properties (like 'event')
-    initializer.properties.forEach((property) => {
-        const channel = property.name.getText();
-        messageTypes[channel] = {};
-        if (ts.isPropertyAssignment(property)) {
-            const nestedObject = property.initializer;
-            if (ts.isObjectLiteralExpression(nestedObject)) {
-                const keys = nestedObject.properties.map((p) => p.name?.getText());
-                for (const route of keys) {
-                    if (route) {
-                        const result = getFunctionTypes(checker, nestedObject, {
-                            funcName: route,
-                            inputIndex: 0,
-                            outputIndex: 1,
-                            typesMap,
+    return undefined;
+}
+/**
+ * Resolve a handler expression (Identifier, CallExpression, or { func })
+ * into its underlying function name.
+ */
+function getHandlerNameFromExpression(expr, checker) {
+    // Handle direct identifier case (which includes shorthand properties)
+    if (ts.isIdentifier(expr)) {
+        const sym = checker.getSymbolAtLocation(expr);
+        if (sym) {
+            let resolvedSym = sym;
+            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
+                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
+            }
+            // Try to get declarations
+            const decls = resolvedSym.declarations ?? [];
+            if (decls.length > 0) {
+                const decl = decls[0];
+                // For variable declarations, look at the initializer
+                if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                    if (ts.isCallExpression(decl.initializer) ||
+                        ts.isArrowFunction(decl.initializer) ||
+                        ts.isFunctionExpression(decl.initializer)) {
+                        // Extract function name from the declaration's initializer
+                        const { pikkuFuncName } = extractFunctionName(decl.initializer, checker);
+                        return pikkuFuncName;
+                    }
+                }
+                // For function declarations, use directly
+                else if (ts.isFunctionDeclaration(decl)) {
+                    const { pikkuFuncName } = extractFunctionName(decl, checker);
+                    return pikkuFuncName;
+                }
+            }
+        }
+        // Fallback: try to extract directly from the identifier
+        const { pikkuFuncName } = extractFunctionName(expr, checker);
+        return pikkuFuncName;
+    }
+    // Handle call expressions
+    if (ts.isCallExpression(expr)) {
+        const { pikkuFuncName } = extractFunctionName(expr, checker);
+        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 null;
+}
+/**
+ * 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) {
+    const result = {};
+    const onMsgRouteProp = getPropertyAssignmentInitializer(obj, 'onMessageRoute', true, checker);
+    if (!onMsgRouteProp)
+        return result;
+    if (!onMsgRouteProp || !ts.isObjectLiteralExpression(onMsgRouteProp))
+        return result;
+    for (const chanElem of onMsgRouteProp.properties) {
+        const chanInit = getInitializerOf(chanElem);
+        if (!chanInit || !ts.isObjectLiteralExpression(chanInit))
+            continue;
+        const channelKey = chanElem.name.getText();
+        result[channelKey] = {};
+        for (const routeElem of chanInit.properties) {
+            const init = getInitializerOf(routeElem);
+            if (!init)
+                continue;
+            const routeKey = routeElem.name.getText();
+            // For shorthand properties, we need to resolve the identifier to its declaration
+            if (ts.isShorthandPropertyAssignment(routeElem)) {
+                // Get the symbol for the shorthand property
+                const shorthandSym = checker.getShorthandAssignmentValueSymbol(routeElem);
+                if (shorthandSym &&
+                    shorthandSym.declarations &&
+                    shorthandSym.declarations.length > 0) {
+                    const shorthandDecl = shorthandSym.declarations[0];
+                    if (!shorthandDecl) {
+                        throw new Error(`No declaration found for shorthand property '${routeKey}'`);
+                    }
+                    // Handle import specifiers
+                    if (ts.isImportSpecifier(shorthandDecl)) {
+                        // Get the imported symbol
+                        const importedSymbol = checker.getSymbolAtLocation(shorthandDecl.name);
+                        if (importedSymbol) {
+                            // Try to resolve the alias to get the original symbol
+                            let resolvedSymbol = importedSymbol;
+                            if (resolvedSymbol.flags & ts.SymbolFlags.Alias) {
+                                resolvedSymbol =
+                                    checker.getAliasedSymbol(resolvedSymbol) ?? resolvedSymbol;
+                            }
+                            // Try to get the declarations of the resolved symbol
+                            const importDecls = resolvedSymbol.declarations ?? [];
+                            if (importDecls.length > 0) {
+                                const importDecl = importDecls[0];
+                                // Handle different kinds of declarations
+                                if (ts.isVariableDeclaration(importDecl) &&
+                                    importDecl.initializer) {
+                                    // Extract from the initializer if it's a function
+                                    if (ts.isArrowFunction(importDecl.initializer) ||
+                                        ts.isFunctionExpression(importDecl.initializer) ||
+                                        ts.isCallExpression(importDecl.initializer)) {
+                                        const { pikkuFuncName } = extractFunctionName(importDecl.initializer, checker);
+                                        const handlerName = pikkuFuncName;
+                                        // Look up in the registry
+                                        const fnMeta = state.functions.meta[handlerName];
+                                        if (fnMeta) {
+                                            result[channelKey][routeKey] = {
+                                                pikkuFuncName: handlerName,
+                                                inputs: fnMeta.inputs ?? null,
+                                                outputs: fnMeta.outputs ?? null,
+                                            };
+                                            continue;
+                                        }
+                                    }
+                                }
+                                else if (ts.isFunctionDeclaration(importDecl)) {
+                                    // Extract from the function declaration
+                                    const { pikkuFuncName } = extractFunctionName(importDecl, checker);
+                                    const handlerName = pikkuFuncName;
+                                    // Look up in the registry
+                                    const fnMeta = state.functions.meta[handlerName];
+                                    if (fnMeta) {
+                                        result[channelKey][routeKey] = {
+                                            pikkuFuncName: handlerName,
+                                            inputs: fnMeta.inputs ?? null,
+                                            outputs: fnMeta.outputs ?? null,
+                                        };
+                                        continue;
+                                    }
+                                }
+                                else if (ts.isExportSpecifier(importDecl)) {
+                                    // For re-exports, we need to follow another level of indirection
+                                    const exportSymbol = checker.getSymbolAtLocation(importDecl.name);
+                                    if (exportSymbol) {
+                                        let resolvedExportSymbol = exportSymbol;
+                                        if (resolvedExportSymbol.flags & ts.SymbolFlags.Alias) {
+                                            resolvedExportSymbol =
+                                                checker.getAliasedSymbol(resolvedExportSymbol) ??
+                                                    resolvedExportSymbol;
+                                        }
+                                        const exportDecls = resolvedExportSymbol.declarations ?? [];
+                                        if (exportDecls.length > 0) {
+                                            const exportDecl = exportDecls[0];
+                                            if (ts.isVariableDeclaration(exportDecl) &&
+                                                exportDecl.initializer) {
+                                                const { pikkuFuncName } = extractFunctionName(exportDecl.initializer, checker);
+                                                const handlerName = pikkuFuncName;
+                                                const fnMeta = state.functions.meta[handlerName];
+                                                if (fnMeta) {
+                                                    result[channelKey][routeKey] = {
+                                                        pikkuFuncName: handlerName,
+                                                        inputs: fnMeta.inputs ?? null,
+                                                        outputs: fnMeta.outputs ?? null,
+                                                    };
+                                                    continue;
+                                                }
+                                            }
+                                            else if (ts.isFunctionDeclaration(exportDecl)) {
+                                                const { pikkuFuncName } = extractFunctionName(exportDecl, checker);
+                                                const handlerName = pikkuFuncName;
+                                                const fnMeta = state.functions.meta[handlerName];
+                                                if (fnMeta) {
+                                                    result[channelKey][routeKey] = {
+                                                        pikkuFuncName: handlerName,
+                                                        inputs: fnMeta.inputs ?? null,
+                                                        outputs: fnMeta.outputs ?? null,
+                                                    };
+                                                    continue;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // As a fallback, try to look up by name
+                        const funcName = shorthandDecl.name.getText();
+                        // Look for any function in the registry that ends with this name
+                        const possibleMatch = Object.keys(state.functions.meta).find((key) => {
+                            const parts = key.split('_');
+                            const filename = parts[parts.length - 3] || '';
+                            return filename.endsWith(funcName);
                         });
-                        const inputs = result?.inputs || null;
-                        const outputs = result?.outputs || null;
-                        messageTypes[channel][route] = { inputs, outputs };
+                        if (possibleMatch) {
+                            const fnMeta = state.functions.meta[possibleMatch];
+                            if (!fnMeta) {
+                                console.error(`No function metadata found for handler '${possibleMatch}'`);
+                                continue;
+                            }
+                            result[channelKey][routeKey] = {
+                                pikkuFuncName: possibleMatch,
+                                inputs: fnMeta.inputs ?? null,
+                                outputs: fnMeta.outputs ?? null,
+                            };
+                            continue;
+                        }
+                    }
+                    else {
+                        // Handle other declaration types (variable, function, etc.)
+                        let actualFunction = undefined;
+                        if (ts.isVariableDeclaration(shorthandDecl)) {
+                            // Check if it has an initializer
+                            if (shorthandDecl.initializer) {
+                                // If it's a function expression or similar, use that
+                                if (ts.isArrowFunction(shorthandDecl.initializer) ||
+                                    ts.isFunctionExpression(shorthandDecl.initializer) ||
+                                    ts.isCallExpression(shorthandDecl.initializer)) {
+                                    actualFunction = shorthandDecl.initializer;
+                                }
+                            }
+                        }
+                        else if (ts.isFunctionDeclaration(shorthandDecl)) {
+                            actualFunction = shorthandDecl;
+                        }
+                        // 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 handlerName = pikkuFuncName;
+                            // Now use this handlerName to look up in the registry
+                            const fnMeta = state.functions.meta[handlerName];
+                            if (fnMeta) {
+                                result[channelKey][routeKey] = {
+                                    pikkuFuncName: handlerName,
+                                    inputs: fnMeta.inputs ?? null,
+                                    outputs: fnMeta.outputs ?? null,
+                                };
+                                continue; // Skip the normal processing below
+                            }
+                        }
                     }
                 }
             }
-            else {
-                console.warn('Nested property is not an object literal:', nestedObject);
+            // Normal processing for non-shorthand properties
+            const handlerName = getHandlerNameFromExpression(init, checker);
+            if (!handlerName) {
+                console.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}'`);
+                continue;
+            }
+            result[channelKey][routeKey] = {
+                pikkuFuncName: handlerName,
+                inputs: fnMeta.inputs ?? null,
+                outputs: fnMeta.outputs ?? null,
+            };
         }
-        else {
-            console.warn(`Property "${property.getText()}" is a ${ts.SyntaxKind[property.kind]}`);
-        }
-    });
-    return messageTypes;
-};
-export const addChannel = (node, checker, state, filters) => {
-    if (!ts.isCallExpression(node)) {
-        return;
     }
-    const args = node.arguments;
-    const firstArg = args[0];
-    const expression = node.expression;
-    // Check if the call is to addRoute
-    if (!ts.isIdentifier(expression) || expression.text !== 'addChannel') {
+    return result;
+}
+/**
+ * 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) {
+    if (!ts.isCallExpression(node))
         return;
-    }
-    if (!firstArg) {
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'addChannel')
+        return;
+    const first = args[0];
+    if (!first || !ts.isObjectLiteralExpression(first))
+        return;
+    const obj = first;
+    const name = getPropertyValue(obj, 'name');
+    const route = getPropertyValue(obj, 'route') ?? '';
+    if (!name) {
+        console.error('Channel name is required');
         return;
     }
-    let docs;
-    let paramsValues = [];
-    let queryValues = [];
-    let tags = undefined;
-    let inputType = null;
-    let route = null;
-    let name = null;
-    // Check if the first argument is an object literal
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        name = getPropertyValue(obj, 'name');
-        route = getPropertyValue(obj, 'route');
-        if (!name) {
-            console.error('Channel name is required');
-            return;
-        }
-        if (route) {
-            const { keys } = pathToRegexp(route);
-            paramsValues = keys.reduce((result, { type, name }) => {
-                if (type === 'param') {
-                    result.push(name);
-                }
-                return result;
-            }, []);
+    // path parameters
+    const params = route
+        ? pathToRegexp(route)
+            .keys.filter((k) => k.type === 'param')
+            .map((k) => k.name)
+        : [];
+    const docs = getPropertyValue(obj, 'docs');
+    const tags = getPropertyValue(obj, 'tags');
+    const query = getPropertyValue(obj, 'query');
+    if (!matchesFilters(filters, { tags }, { type: 'channel', name }))
+        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 fnMeta = handlerName && state.functions.meta[handlerName];
+        if (!fnMeta) {
+            console.error(`No function metadata for onMessage handler '${handlerName}'`);
+            throw new Error();
         }
         else {
-            route = '';
-        }
-        docs = getPropertyValue(obj, 'docs') || undefined;
-        queryValues = getPropertyValue(obj, 'query') || [];
-        tags = getPropertyValue(obj, 'tags') || undefined;
-        const connect = !!getPropertyAssignment(obj, 'onConnect');
-        const disconnect = !!getPropertyAssignment(obj, 'onDisconnect');
-        const { inputs, outputs } = getFunctionTypes(checker, obj, {
-            funcName: 'onMessage',
-            inputIndex: 0,
-            outputIndex: 1,
-            typesMap: state.channels.typesMap,
-        });
-        const message = { inputs, outputs };
-        const messageRoutes = addMessagesRoutes(obj, checker, state.channels.typesMap);
-        if (!matchesFilters(filters, { tags }, { type: 'channel', name })) {
-            return;
+            message = {
+                pikkuFuncName: extractFunctionName(onMsgProp, checker)
+                    .pikkuFuncName,
+                inputs: fnMeta.inputs ?? null,
+                outputs: fnMeta.outputs ?? null,
+            };
         }
-        state.channels.files.add(node.getSourceFile().fileName);
-        state.channels.meta.push({
-            name,
-            route,
-            input: inputType,
-            params: paramsValues.length > 0 ? paramsValues : undefined,
-            query: queryValues.length > 0 ? queryValues : undefined,
-            inputTypes: getInputTypes(state.channels.metaInputTypes, 'get', inputType, queryValues, paramsValues),
-            connect,
-            disconnect,
-            message,
-            messageRoutes,
-            docs,
-            tags,
-        });
     }
-};
+    // nested message-routes
+    const messageRoutes = addMessagesRoutes(obj, state, checker);
+    // record into state
+    state.channels.files.add(node.getSourceFile().fileName);
+    state.channels.meta[name] = {
+        name,
+        route,
+        input: null,
+        params: params.length ? params : undefined,
+        query: query?.length ? query : undefined,
+        inputTypes: getInputTypes(state.channels.metaInputTypes, 'get', message?.inputs?.[0] ?? null, query, params),
+        connectPikkuFuncName: connect
+            ? extractFunctionName(connect, checker).pikkuFuncName
+            : null,
+        connect: !!connect,
+        disconnectPikkuFuncName: disconnect
+            ? extractFunctionName(disconnect, checker).pikkuFuncName
+            : null,
+        disconnect: !!disconnect,
+        message,
+        messageRoutes,
+        docs: docs ?? undefined,
+        tags: tags ?? undefined,
+    };
+}

package/dist/add-functions.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { InspectorState, InspectorFilters } 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): void;