@pikku/inspector 0.6.3 → 0.7.0

package/dist/events/add-http-route.js

@@ -0,0 +1,83 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../get-property-value.js';
+import { pathToRegexp } from 'path-to-regexp';
+import { matchesFilters } from '../utils.js';
+/**
+ * Populate metaInputTypes for a given route based on method, input type,
+ * query and params. Returns undefined (we only mutate metaTypes).
+ */
+export const getInputTypes = (metaTypes, methodType, inputType, queryValues, paramsValues) => {
+    if (!inputType)
+        return;
+    metaTypes.set(inputType, {
+        query: queryValues,
+        params: paramsValues,
+        body: ['post', 'put', 'patch'].includes(methodType)
+            ? [...new Set([...queryValues, ...paramsValues])]
+            : [],
+    });
+    return;
+};
+/**
+ * Simplified addRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export const addRoute = (node, checker, state, filters) => {
+    // only look at calls
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'addRoute')
+        return;
+    // must pass an object literal
+    const firstArg = args[0];
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    const obj = firstArg;
+    // --- extract HTTP metadata ---
+    const route = getPropertyValue(obj, 'route');
+    if (!route)
+        return;
+    const keys = pathToRegexp(route).keys;
+    const params = keys
+        .filter(k => k.type === 'param')
+        .map(k => k.name);
+    const method = getPropertyValue(obj, 'method')?.toLowerCase() || 'get';
+    const docs = getPropertyValue(obj, 'docs') || undefined;
+    const tags = getPropertyValue(obj, 'tags') || undefined;
+    const query = getPropertyValue(obj, 'query') || [];
+    if (!matchesFilters(filters, { tags }, { type: 'http', name: route })) {
+        return;
+    }
+    // --- find the referenced function ---
+    const funcProp = obj.properties.find(p => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'func');
+    if (!funcProp || !ts.isIdentifier(funcProp.initializer)) {
+        console.error(`• No valid 'func' property for route '${route}'.`);
+        return;
+    }
+    const funcName = funcProp.initializer.text;
+    console.log(state.functions);
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta.find(m => m.name === funcName);
+    if (!fnMeta) {
+        console.error(`• No function metadata found for '${funcName}'.`);
+        return;
+    }
+    // --- compute inputTypes (body/query/params) ---
+    const inputTypes = getInputTypes(state.http.metaInputTypes, method, fnMeta.input, query, params);
+    // --- record route ---
+    state.http.files.add(node.getSourceFile().fileName);
+    state.http.meta.push({
+        route,
+        method: method,
+        input: fnMeta.input,
+        output: fnMeta.output,
+        params: params.length > 0 ? params : undefined,
+        query: query.length > 0 ? query : undefined,
+        inputTypes,
+        docs,
+        tags,
+    });
+};

package/dist/events/add-schedule.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { InspectorFilters, InspectorState } from '../types.js';
+export declare const addSchedule: (node: ts.Node, _checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/events/add-schedule.js

@@ -0,0 +1,38 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../get-property-value.js';
+import { matchesFilters } from '../utils.js';
+export const addSchedule = (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 addScheduledTask
+    if (!ts.isIdentifier(expression) || expression.text !== 'addScheduledTask') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const scheduleValue = getPropertyValue(obj, 'schedule');
+        const docs = getPropertyValue(obj, 'docs') || undefined;
+        const tags = getPropertyValue(obj, 'tags') || undefined;
+        if (!nameValue || !scheduleValue) {
+            return;
+        }
+        if (!matchesFilters(filters, { tags }, { type: 'schedule', name: nameValue })) {
+            return;
+        }
+        state.scheduledTasks.files.add(node.getSourceFile().fileName);
+        state.scheduledTasks.meta.push({
+            name: nameValue,
+            schedule: scheduleValue,
+            docs,
+            tags,
+        });
+    }
+};

package/dist/inspector.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { visit } from './visit.js';
+import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 export const normalizeHTTPTypes = (httpState) => {
     return httpState;
@@ -18,6 +18,11 @@ export const inspect = (routeFiles, filters) => {
         singletonServicesFactories: new Map(),
         sessionServicesFactories: new Map(),
         configFactories: new Map(),
+        functions: {
+            typesMap: new TypesMap(),
+            meta: {},
+            files: new Set(),
+        },
         http: {
             typesMap: new TypesMap(),
             metaInputTypes: new Map(),
@@ -28,15 +33,20 @@ export const inspect = (routeFiles, filters) => {
             typesMap: new TypesMap(),
             metaInputTypes: new Map(),
             files: new Set(),
-            meta: [],
+            meta: {},
         },
         scheduledTasks: {
-            meta: [],
+            meta: {},
             files: new Set(),
         },
     };
+    // First sweep: add all functions
+    for (const sourceFile of sourceFiles) {
+        ts.forEachChild(sourceFile, (child) => visitSetup(checker, child, state, filters));
+    }
+    // Second sweep: add all transports
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visit(checker, child, state, filters));
+        ts.forEachChild(sourceFile, (child) => visitRoutes(checker, child, state, filters));
     }
     // Normalise the typesMap
     state.http = normalizeHTTPTypes(state.http);

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import { ChannelsMeta } from '@pikku/core/channel';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
 import { TypesMap } from './types-map.js';
+import { FunctionsMeta } from '@pikku/core';
 export type PathToNameAndType = Map<string, {
     variable: string;
     type: string | null;
@@ -12,22 +13,17 @@ export type MetaInputTypes = Map<string, {
     params: string[] | undefined;
     body: string[] | undefined;
 }>;
-export type APIFunctionMeta = Array<{
-    name: string;
-    input: string;
-    output: string;
-    file: string;
-}>;
-export type InspectorAPIFunction = {
-    typesMap: TypesMap;
-    meta: APIFunctionMeta;
-};
 export interface InspectorHTTPState {
     typesMap: TypesMap;
     metaInputTypes: MetaInputTypes;
     meta: HTTPRoutesMeta;
     files: Set<string>;
 }
+export interface InspectorFunctionState {
+    typesMap: TypesMap;
+    meta: FunctionsMeta;
+    files: Set<string>;
+}
 export interface InspectorChannelState {
     typesMap: TypesMap;
     metaInputTypes: MetaInputTypes;
@@ -45,6 +41,7 @@ export interface InspectorState {
     sessionServicesFactories: PathToNameAndType;
     configFactories: PathToNameAndType;
     http: InspectorHTTPState;
+    functions: InspectorFunctionState;
     channels: InspectorChannelState;
     scheduledTasks: {
         meta: ScheduledTasksMeta;

package/dist/utils.d.ts

@@ -1,33 +1,28 @@
 import * as ts from 'typescript';
-import { TypesMap } from './types-map.js';
 import { InspectorFilters } from './types.js';
-type FunctionTypes = {
-    inputTypes: ts.Type[];
-    inputs: null | string[];
-    outputTypes: ts.Type[];
-    outputs: null | string[];
+type ExtractedFunctionName = {
+    pikkuFuncName: string;
+    name: string;
+    exportedName: string | null;
+    functionName: string | null;
+    propertyName: string | null;
 };
+/**
+ * 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): 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 extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker): ExtractedFunctionName;
 export declare const extractTypeKeys: (type: ts.Type) => string[];
-export declare const nullifyTypes: (type: string | null) => string | null;
-export declare const getNamesAndTypes: (checker: ts.TypeChecker, typesMap: TypesMap, direction: "Input" | "Output", funcName: string, type: ts.Type) => {
-    names: string[];
-    types: ts.Type[];
-};
-export declare const isPrimitiveType: (type: ts.Type) => boolean;
-export declare const resolveUnionTypes: (checker: ts.TypeChecker, type: ts.Type) => {
-    types: ts.Type[];
-    names: string[];
-};
-export declare const resolveTypeImports: (type: ts.Type, resolvedTypes: TypesMap, isCustom: boolean) => string[];
-export declare const getPropertyAssignment: (obj: ts.ObjectLiteralExpression, name: string) => ts.ObjectLiteralElementLike | null;
-export declare const getTypeArgumentsOfType: (checker: ts.TypeChecker, type: ts.Type) => readonly ts.Type[] | null;
-export declare const getFunctionTypes: (checker: ts.TypeChecker, obj: ts.ObjectLiteralExpression, { typesMap, funcName, subFunctionName, inputIndex, outputIndex, }: {
-    typesMap: TypesMap;
-    subFunctionName?: string;
-    funcName: string;
-    inputIndex: number;
-    outputIndex: number;
-}) => FunctionTypes;
+export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;
 export declare const matchesFilters: (filters: InspectorFilters, params: {
     tags?: string[];
 }, meta: {