@pikku/inspector 0.11.2 → 0.12.0

package/dist/utils/ensure-function-metadata.js

@@ -1,12 +1,172 @@
+import * as ts from 'typescript';
+import { funcIdToTypeName } from './extract-function-name.js';
+import { getCommonWireMetaData } from './get-property-value.js';
+import { resolveMiddleware } from './middleware.js';
+import { resolvePermissions } from './permissions.js';
+function isVoidLike(type) {
+    return !!(type.flags &
+        (ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike));
+}
+function isPromiseOfVoid(checker, type) {
+    if (!type?.symbol)
+        return false;
+    const isPromise = type.symbol.name === 'Promise' &&
+        checker.getFullyQualifiedName(type.symbol).includes('Promise');
+    if (!isPromise)
+        return false;
+    const inner = type.aliasTypeArguments?.[0] ??
+        type.typeArguments?.[0];
+    return !!inner && isVoidLike(inner);
+}
+function unwrapPromise(checker, type) {
+    if (type.isUnion()) {
+        const nonVoid = type.types.filter((t) => !isVoidLike(t) && !isPromiseOfVoid(checker, t));
+        if (nonVoid.length === 1) {
+            return unwrapPromise(checker, nonVoid[0]);
+        }
+        if (nonVoid.length > 1) {
+            return unwrapPromise(checker, nonVoid[0]);
+        }
+        return type;
+    }
+    if (!type?.symbol)
+        return type;
+    const isPromise = type.symbol.name === 'Promise' &&
+        checker.getFullyQualifiedName(type.symbol).includes('Promise');
+    if (isPromise && type.aliasTypeArguments?.length === 1) {
+        return type.aliasTypeArguments[0];
+    }
+    if (isPromise && type.typeArguments?.length === 1) {
+        return type.typeArguments[0];
+    }
+    return type;
+}
+function resolveTypeName(checker, type, state, funcName, direction) {
+    if (type.flags & (ts.TypeFlags.VoidLike | ts.TypeFlags.Null))
+        return null;
+    const typeStr = checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation);
+    if (!typeStr ||
+        typeStr === 'void' ||
+        typeStr === 'undefined' ||
+        typeStr === 'null')
+        return null;
+    const isSimpleName = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(typeStr);
+    if (isSimpleName) {
+        const symbol = type.aliasSymbol || type.getSymbol();
+        if (symbol) {
+            const decl = symbol.getDeclarations()?.[0];
+            if (decl) {
+                const path = decl.getSourceFile().fileName;
+                if (!state.functions.typesMap.exists(typeStr, path)) {
+                    state.functions.typesMap.addType(typeStr, path);
+                }
+            }
+        }
+        return typeStr;
+    }
+    const aliasName = funcIdToTypeName(funcName) + direction;
+    state.functions.typesMap.addCustomType(aliasName, typeStr, []);
+    return aliasName;
+}
+function getFirstCallSignature(type) {
+    const sigs = type.getCallSignatures();
+    if (sigs.length > 0)
+        return sigs[0];
+    if (type.isUnion()) {
+        for (const member of type.types) {
+            const memberSigs = member.getCallSignatures();
+            if (memberSigs.length > 0)
+                return memberSigs[0];
+        }
+    }
+    return undefined;
+}
+function resolveFromConfigTypeArgs(state, pikkuFuncId, configType, checker, meta) {
+    const typeArgs = configType.aliasTypeArguments ??
+        configType.typeArguments;
+    if (!typeArgs || typeArgs.length < 2)
+        return;
+    const inputType = typeArgs[0];
+    const outputType = typeArgs[1];
+    if (!meta.inputs || meta.inputs.length === 0) {
+        const inputName = resolveTypeName(checker, inputType, state, pikkuFuncId, 'Input');
+        if (inputName) {
+            meta.inputs = [inputName];
+            meta.inputSchemaName = inputName;
+        }
+    }
+    if (!meta.outputs || meta.outputs.length === 0) {
+        const resolvedOutput = unwrapPromise(checker, outputType);
+        const outputName = resolveTypeName(checker, resolvedOutput, state, pikkuFuncId, 'Output');
+        if (outputName) {
+            meta.outputs = [outputName];
+            meta.outputSchemaName = outputName;
+        }
+    }
+}
+function resolveFuncConfigTypes(state, pikkuFuncId, funcInitializer, checker) {
+    const meta = state.functions.meta[pikkuFuncId];
+    if (!meta || (meta.inputs && meta.inputs.length > 0))
+        return;
+    const configType = checker.getTypeAtLocation(funcInitializer);
+    const funcProp = configType.getProperty('func');
+    if (!funcProp)
+        return;
+    const funcType = checker.getTypeOfSymbolAtLocation(funcProp, funcInitializer);
+    const sig = getFirstCallSignature(funcType);
+    if (!sig)
+        return;
+    const params = sig.getParameters();
+    if (params.length >= 2) {
+        const inputType = checker.getTypeOfSymbolAtLocation(params[1], funcInitializer);
+        const inputName = resolveTypeName(checker, inputType, state, pikkuFuncId, 'Input');
+        if (inputName) {
+            meta.inputs = [inputName];
+            meta.inputSchemaName = inputName;
+        }
+    }
+    const rawReturnType = checker.getReturnTypeOfSignature(sig);
+    const outputType = unwrapPromise(checker, rawReturnType);
+    const outputName = resolveTypeName(checker, outputType, state, pikkuFuncId, 'Output');
+    if (outputName) {
+        meta.outputs = [outputName];
+        meta.outputSchemaName = outputName;
+    }
+    resolveFromConfigTypeArgs(state, pikkuFuncId, configType, checker, meta);
+}
+function resolveToPikkuFuncCall(node, checker) {
+    if (ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text.startsWith('pikku')) {
+        return node;
+    }
+    if (ts.isIdentifier(node)) {
+        const sym = checker.getSymbolAtLocation(node);
+        if (sym) {
+            let resolved = sym;
+            if (resolved.flags & ts.SymbolFlags.Alias) {
+                resolved = checker.getAliasedSymbol(resolved) ?? resolved;
+            }
+            const decl = resolved.declarations?.[0];
+            if (decl && ts.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveToPikkuFuncCall(decl.initializer, checker);
+            }
+        }
+    }
+    return null;
+}
 /**
- * Ensures that function metadata exists for a given pikkuFuncName.
+ * Ensures that function metadata exists for a given pikkuFuncId.
  * Creates stub metadata if it doesn't exist (useful for inline functions).
+ * When funcInitializer and checker are provided, resolves types and
+ * extracts tags/middleware/permissions from the pikkuFunc() config.
  */
-export function ensureFunctionMetadata(state, pikkuFuncName, fallbackName) {
-    if (!state.functions.meta[pikkuFuncName]) {
-        state.functions.meta[pikkuFuncName] = {
-            pikkuFuncName,
-            name: fallbackName || pikkuFuncName,
+export function ensureFunctionMetadata(state, pikkuFuncId, fallbackName, funcInitializer, checker, isHelper) {
+    if (!state.functions.meta[pikkuFuncId]) {
+        state.functions.meta[pikkuFuncId] = {
+            pikkuFuncId,
+            functionType: isHelper ? 'helper' : 'inline',
+            name: fallbackName || pikkuFuncId,
             services: { optimized: false, services: [] },
             inputSchemaName: null,
             outputSchemaName: null,
@@ -15,4 +175,58 @@ export function ensureFunctionMetadata(state, pikkuFuncName, fallbackName) {
             middleware: undefined,
         };
     }
+    const meta = state.functions.meta[pikkuFuncId];
+    if (funcInitializer && checker) {
+        let pikkuFuncCall = null;
+        if (ts.isCallExpression(funcInitializer)) {
+            pikkuFuncCall = funcInitializer;
+            resolveFuncConfigTypes(state, pikkuFuncId, pikkuFuncCall, checker);
+            if (!state.typesLookup.has(pikkuFuncId)) {
+                populateTypesLookup(state, pikkuFuncId, pikkuFuncCall, checker);
+            }
+        }
+        else {
+            pikkuFuncCall = resolveToPikkuFuncCall(funcInitializer, checker);
+        }
+        if (pikkuFuncCall) {
+            const firstArg = pikkuFuncCall.arguments[0];
+            if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+                if (!meta.tags) {
+                    const { tags } = getCommonWireMetaData(firstArg, 'Function', fallbackName || pikkuFuncId);
+                    if (tags) {
+                        meta.tags = tags;
+                    }
+                }
+                if (!meta.middleware) {
+                    meta.middleware = resolveMiddleware(state, firstArg, meta.tags, checker);
+                }
+                if (!meta.permissions) {
+                    meta.permissions = resolvePermissions(state, firstArg, meta.tags, checker);
+                }
+            }
+        }
+    }
+}
+function populateTypesLookup(state, pikkuFuncId, funcInitializer, checker) {
+    const typeArgs = funcInitializer.typeArguments;
+    if (typeArgs && typeArgs.length >= 1) {
+        const inputType = checker.getTypeFromTypeNode(typeArgs[0]);
+        state.typesLookup.set(pikkuFuncId, [inputType]);
+        return;
+    }
+    const configType = checker.getTypeAtLocation(funcInitializer);
+    const funcProp = configType.getProperty('func');
+    if (!funcProp)
+        return;
+    const funcType = checker.getTypeOfSymbolAtLocation(funcProp, funcInitializer);
+    const sig = getFirstCallSignature(funcType);
+    if (!sig)
+        return;
+    const params = sig.getParameters();
+    if (params.length >= 2) {
+        const inputType = checker.getTypeOfSymbolAtLocation(params[1], funcInitializer);
+        if (!(inputType.flags & ts.TypeFlags.VoidLike)) {
+            state.typesLookup.set(pikkuFuncId, [inputType]);
+        }
+    }
 }

package/dist/utils/extract-function-name.d.ts

@@ -1,25 +1,14 @@
 import * as ts from 'typescript';
 export type ExtractedFunctionName = {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     name: string;
     explicitName: string | null;
     exportedName: string | null;
-    localName: string | null;
     propertyName: string | null;
+    isHelper: boolean;
 };
-/**
- * Generate a deterministic "anonymous" name for any expression node,
- * but if it's an Identifier pointing to a function, resolve it back
- * to the function's declaration (so you get the true source location).
- */
-export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.TypeChecker, rootDir: string): string;
-/**
- * Updated function to extract and prioritize function names correctly
- * This function follows the priority:
- * 1. Object with a name property
- * 2. Exported name
- * 3. Fallback to deterministic name
- */
+export declare function makeContextBasedId(wiringType: string, ...segments: string[]): string;
+export declare function funcIdToTypeName(id: string): string;
 export declare function extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker, rootDir: string): ExtractedFunctionName;
 /**
  * Helper function to populate the 'name' field based on priority
@@ -28,4 +17,4 @@ export declare function populateNameByPriority(result: ExtractedFunctionName): v
 /**
  * Helper function to check if a variable declaration is a named export
  */
-export declare function isNamedExport(declaration: ts.VariableDeclaration): boolean;
+export declare function isNamedExport(declaration: ts.VariableDeclaration, checker?: ts.TypeChecker): boolean;