@pikku/inspector 0.6.4 → 0.7.1

package/src/add-functions.ts

@@ -0,0 +1,376 @@
+import * as ts from 'typescript'
+import { InspectorState, InspectorFilters } from './types.js'
+import { TypesMap } from './types-map.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+} from './utils.js'
+import { FunctionServicesMeta } from '@pikku/core'
+
+const isValidVariableName = (name: string) => {
+  const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
+  return regex.test(name)
+}
+
+const nullifyTypes = (type: string | null) => {
+  if (
+    type === 'void' ||
+    type === 'undefined' ||
+    type === 'unknown' ||
+    type === 'any'
+  ) {
+    return null
+  }
+  return type
+}
+
+const resolveTypeImports = (
+  type: ts.Type,
+  resolvedTypes: TypesMap,
+  isCustom: boolean
+): string[] => {
+  const types: string[] = []
+
+  const visitType = (currentType: ts.Type) => {
+    const symbol = currentType.aliasSymbol || currentType.getSymbol()
+
+    if (symbol) {
+      const declarations = symbol.getDeclarations()
+      const declaration = declarations?.[0]
+      if (declaration) {
+        const sourceFile = declaration.getSourceFile()
+        const path = sourceFile.fileName
+
+        // Skip built-in utility types or TypeScript lib types
+        if (
+          !path.includes('node_modules/typescript') &&
+          symbol.getName() !== '__type' &&
+          !isPrimitiveType(currentType)
+        ) {
+          const originalName = symbol.getName()
+          // Check if the type is already in the map
+          let uniqueName = resolvedTypes.exists(originalName, path)
+          if (!uniqueName) {
+            if (isCustom) {
+              uniqueName = resolvedTypes.addUniqueType(originalName, path)
+            } else {
+              resolvedTypes.addType(originalName, path)
+              uniqueName = originalName
+            }
+          }
+          types.push(uniqueName)
+        }
+      }
+    }
+
+    if (isCustom) {
+      // Handle nested utility types like Partial, Pick, etc.
+      if (currentType.aliasTypeArguments) {
+        currentType.aliasTypeArguments.forEach(visitType)
+      }
+
+      // Handle intersections and unions
+      if (currentType.isUnionOrIntersection()) {
+        currentType.types.forEach(visitType)
+      }
+
+      // Handle object types with type arguments
+      if (
+        currentType.flags & ts.TypeFlags.Object &&
+        (currentType as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference
+      ) {
+        const typeRef = currentType as ts.TypeReference
+        typeRef.typeArguments?.forEach(visitType)
+      }
+    }
+  }
+
+  visitType(type)
+  return types
+}
+
+const resolveUnionTypes = (
+  checker: ts.TypeChecker,
+  type: ts.Type
+): { types: ts.Type[]; names: string[] } => {
+  const types: ts.Type[] = []
+  const names: string[] = []
+
+  // Check if it's a union type AND not part of an intersection
+  if (type.isUnion() && !(type.flags & ts.TypeFlags.Intersection)) {
+    for (const t of type.types) {
+      const name = nullifyTypes(checker.typeToString(t))
+      if (name) {
+        types.push(t)
+        names.push(name)
+      }
+    }
+  } else {
+    const name = nullifyTypes(checker.typeToString(type))
+    if (name) {
+      types.push(type)
+      names.push(name)
+    }
+  }
+
+  return { types, names }
+}
+
+const getNamesAndTypes = (
+  checker: ts.TypeChecker,
+  typesMap: TypesMap,
+  direction: 'Input' | 'Output',
+  funcName: string,
+  type?: ts.Type
+) => {
+  if (!type) {
+    return { names: [], types: [] }
+  }
+
+  // 1) Handle an explicit void (or undefined) type up front
+  if (type.flags & ts.TypeFlags.VoidLike) {
+    return {
+      names: ['void'],
+      types: [type],
+    }
+  }
+
+  // 2) For unions, resolve all member names/types
+  const { names: rawNames, types: rawTypes } = resolveUnionTypes(checker, type)
+
+  // If the union is exactly [void], we'd have caught it above.
+  // If it's e.g. [string, void], rawNames should already include 'void'.
+
+  // 3) If multiple names or the single name isn't a valid identifier,
+  //    we emit an alias type.
+  const firstName = rawNames[0]
+  if (rawNames.length > 1 || (firstName && !isValidVariableName(firstName))) {
+    const aliasType = rawNames.join(' | ')
+    const aliasName =
+      funcName.charAt(0).toUpperCase() + funcName.slice(1) + direction
+
+    // record the alias in your TypesMap
+    const references = rawTypes
+      .map((t) => resolveTypeImports(t, typesMap, true))
+      .flat()
+
+    typesMap.addCustomType(aliasName, aliasType, references)
+
+    return {
+      names: [aliasName],
+      types: rawTypes,
+    }
+  }
+
+  // 4) Single, valid name → inline it
+  const uniqueNames = rawNames
+    .map((name, i) => {
+      const t = rawTypes[i]
+      if (!t) {
+        throw new Error(`Expected type for name "${name}" in ${funcName}`)
+      }
+      if (isPrimitiveType(t)) {
+        return name
+      }
+      // non-primitive: import/alias it inline
+      return resolveTypeImports(t, typesMap, false)
+    })
+    .flat()
+
+  return {
+    names: uniqueNames,
+    types: rawTypes,
+  }
+}
+
+const isPrimitiveType = (type: ts.Type): boolean => {
+  const primitiveFlags =
+    ts.TypeFlags.Number |
+    ts.TypeFlags.String |
+    ts.TypeFlags.Boolean |
+    ts.TypeFlags.BigInt |
+    ts.TypeFlags.ESSymbol |
+    ts.TypeFlags.Void |
+    ts.TypeFlags.Undefined |
+    ts.TypeFlags.Null |
+    ts.TypeFlags.Any |
+    ts.TypeFlags.Unknown |
+    ts.TypeFlags.VoidLike
+
+  return (type.flags & primitiveFlags) !== 0
+}
+
+/**
+ * If `type` is a `Promise<T>`, return `T`, otherwise return `type` itself.
+ */
+function unwrapPromise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+  if (!type?.symbol) return type
+
+  const isPromise =
+    type.symbol.name === 'Promise' &&
+    checker.getFullyQualifiedName(type.symbol).includes('Promise')
+
+  // aliasTypeArguments covers most Promise<T> cases
+  if (isPromise && type.aliasTypeArguments?.length === 1) {
+    return type.aliasTypeArguments[0]!
+  }
+
+  // fallback for raw TypeReference
+  if (isPromise && (type as ts.TypeReference).typeArguments?.length === 1) {
+    return (type as ts.TypeReference).typeArguments![0]!
+  }
+
+  return type
+}
+
+/**
+ * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
+ * then push into state.functions.meta.
+ */
+export function addFunctions(
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  filters: InspectorFilters
+) {
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args, typeArguments } = node
+
+  // only handle calls like pikkuFunc(...)
+  if (!ts.isIdentifier(expression)) {
+    return
+  }
+
+  // Match identifiers that contain both "pikku" and "func" (case insensitive)
+  const pikkuFuncPattern = /pikku.*func/i
+  if (!pikkuFuncPattern.test(expression.text)) {
+    return
+  }
+
+  // only handle calls like pikkuFunc(...)
+  if (!ts.isIdentifier(expression) || !expression.text.startsWith('pikku')) {
+    return
+  }
+
+  if (args.length === 0) return
+
+  const { pikkuFuncName, name } = extractFunctionName(node, checker)
+
+  // determine the actual handler expression:
+  // either the `func` prop or the first argument directly
+  let handlerNode: ts.Expression = args[0]!
+  if (ts.isObjectLiteralExpression(handlerNode)) {
+    const fnProp = getPropertyAssignmentInitializer(
+      handlerNode,
+      'func',
+      true,
+      checker
+    )
+    if (
+      !fnProp ||
+      (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))
+    ) {
+      console.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.`)
+    return
+  }
+
+  const services: FunctionServicesMeta = {
+    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) &&
+      !firstParam.name.text.startsWith('_')
+    ) {
+      services.optimized = false
+    }
+  }
+
+  // --- Generics → ts.Type[], unwrapped from Promise ---
+  const genericTypes: ts.Type[] = (typeArguments ?? [])
+    .map((tn) => checker.getTypeFromTypeNode(tn))
+    .map((t) => unwrapPromise(checker, t))
+
+  // --- Input Extraction ---
+  let { names: inputNames, types: inputTypes } = getNamesAndTypes(
+    checker,
+    state.functions.typesMap,
+    'Input',
+    name,
+    genericTypes[0]
+  )
+  if (inputTypes.length === 0) {
+    console.warn(
+      `\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`
+    )
+  }
+
+  // --- Output Extraction ---
+  let outputNames: string[] = []
+  if (genericTypes.length >= 2) {
+    outputNames = getNamesAndTypes(
+      checker,
+      state.functions.typesMap,
+      'Output',
+      name,
+      genericTypes[1]
+    ).names
+  } else {
+    const sig = checker.getSignatureFromDeclaration(handlerNode)
+    if (sig) {
+      const rawRet = checker.getReturnTypeOfSignature(sig)
+      const unwrapped = unwrapPromise(checker, rawRet)
+      outputNames = getNamesAndTypes(
+        checker,
+        state.functions.typesMap,
+        'Output',
+        pikkuFuncName,
+        unwrapped
+      ).names
+    }
+  }
+
+  // --- Record metadata ---
+  state.functions.files.add(node.getSourceFile().fileName)
+
+  if (inputNames.length > 1) {
+    console.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,
+    inputs: inputNames.filter((n) => n !== 'void') ?? null,
+    outputs: outputNames.filter((n) => n !== 'void') ?? null,
+  }
+}

package/src/add-http-route.ts

@@ -3,136 +3,121 @@ import { getPropertyValue } from './get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
 import { HTTPMethod } from '@pikku/core/http'
 import { APIDocs } from '@pikku/core'
-import { extractTypeKeys, getFunctionTypes, matchesFilters } from './utils.js'
-import { MetaInputTypes, InspectorState, InspectorFilters } from './types.js'
-
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
+import { InspectorState, InspectorFilters } from './types.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: MetaInputTypes,
+  metaTypes: Map<
+    string,
+    { query?: string[]; params?: string[]; body?: string[] }
+  >,
   methodType: string,
   inputType: string | null,
   queryValues: string[],
   paramsValues: string[]
-) => {
-  if (!inputType) {
-    return undefined
-  }
-
-  if (inputType) {
-    metaTypes.set(inputType, {
-      query: queryValues,
-      params: paramsValues,
-      body: ['post', 'put', 'patch'].includes(methodType)
-        ? [...new Set([...queryValues, ...paramsValues])]
-        : [],
-    })
-  }
-
-  return undefined
+): undefined => {
+  if (!inputType) return
+  metaTypes.set(inputType, {
+    query: queryValues,
+    params: paramsValues,
+    body: ['post', 'put', 'patch'].includes(methodType)
+      ? [...new Set([...queryValues, ...paramsValues])]
+      : [],
+  })
+  return
 }
 
-export const addRoute = (
+/**
+ * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export const addHTTPRoute = (
   node: ts.Node,
   checker: ts.TypeChecker,
   state: InspectorState,
   filters: InspectorFilters
 ) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
+  // only look at calls
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args } = node
+  if (!ts.isIdentifier(expression) || expression.text !== 'addHTTPRoute') return
 
-  const args = node.arguments
+  // must pass an object literal
   const firstArg = args[0]
-  const expression = node.expression
+  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return
+  const obj = firstArg
+
+  // --- extract HTTP metadata ---
+  const route = getPropertyValue(obj, 'route') as string | null
+  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') as string)?.toLowerCase() || 'get'
+  const docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
+  const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+  const query = (getPropertyValue(obj, 'query') as string[]) || []
 
-  // Check if the call is to addRoute
-  if (!ts.isIdentifier(expression) || expression.text !== 'addRoute') {
+  if (!matchesFilters(filters, { tags }, { type: 'http', name: route })) {
     return
   }
 
-  if (!firstArg) {
+  // --- find the referenced function ---
+  const funcInitializer = getPropertyAssignmentInitializer(
+    obj,
+    'func',
+    true,
+    checker
+  )
+  if (!funcInitializer) {
+    console.error(`• No valid 'func' property for route '${route}'.`)
     return
   }
 
-  let docs: APIDocs | undefined
-  let methodValue: string | null = null
-  let paramsValues: string[] | null = []
-  let queryValues: string[] | [] = []
-  let tags: string[] | [] = []
-  let routeValue: string | null = null
+  const funcName = extractFunctionName(funcInitializer, checker).pikkuFuncName
 
-  // Check if the first argument is an object literal
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    routeValue = getPropertyValue(obj, 'route') as string | null
-    if (!routeValue) {
-      return
-    }
-
-    const { keys } = pathToRegexp(routeValue)
-    paramsValues = keys.reduce((result, { type, name }) => {
-      if (type === 'param') {
-        result.push(name)
-      }
-      return result
-    }, [] as string[])
-
-    docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
-    methodValue = getPropertyValue(obj, 'method') as string
-    queryValues = (getPropertyValue(obj, 'query') as string[]) || []
-    tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    if (
-      !matchesFilters(filters, { tags }, { type: 'http', name: routeValue })
-    ) {
-      return
-    }
-
-    let { inputs, outputs, inputTypes } = getFunctionTypes(checker, obj, {
-      funcName: 'func',
-      inputIndex: 0,
-      outputIndex: 1,
-      typesMap: state.http.typesMap,
-    })
-
-    const input = inputs ? inputs[0] || null : null
-    const output = outputs ? outputs[0] || null : null
-
-    if (inputs && inputs?.length > 1) {
-      console.error(
-        `Only one input type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${inputs.join('\n\t')}`
-      )
-    }
-
-    if (outputs && outputs?.length > 1) {
-      console.error(
-        `Only one output type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${outputs.join('\n\t')}`
-      )
-    }
-
-    if (inputTypes[0] && !['post', 'put', 'patch'].includes(methodValue)) {
-      queryValues = [
-        ...new Set([...queryValues, ...extractTypeKeys(inputTypes[0])]),
-      ].filter((query) => !paramsValues?.includes(query))
-    }
-
-    state.http.files.add(node.getSourceFile().fileName)
-    state.http.meta.push({
-      route: routeValue,
-      method: methodValue! as HTTPMethod,
-      input,
-      output,
-      params: paramsValues.length > 0 ? paramsValues : undefined,
-      query: queryValues.length > 0 ? queryValues : undefined,
-      inputTypes: getInputTypes(
-        state.http.metaInputTypes,
-        methodValue,
-        input,
-        queryValues,
-        paramsValues
-      ),
-      docs,
-      tags,
-    })
+  // lookup existing function metadata
+  const fnMeta = state.functions.meta[funcName]
+  if (!fnMeta) {
+    console.log(Object.keys(state.functions.meta))
+    console.error(`• No function metadata found for '${funcName}'.`)
+    return
   }
+  const input = fnMeta.inputs?.[0] || null
+  const output = fnMeta.outputs?.[0] || null
+
+  // --- compute inputTypes (body/query/params) ---
+  const inputTypes = getInputTypes(
+    state.http.metaInputTypes,
+    method,
+    input,
+    query,
+    params
+  )
+
+  // --- record route ---
+  state.http.files.add(node.getSourceFile().fileName)
+  state.http.meta.push({
+    pikkuFuncName: funcName,
+    route,
+    method: method as HTTPMethod,
+    input,
+    output,
+    params: params.length > 0 ? params : undefined,
+    query: query.length > 0 ? query : undefined,
+    inputTypes,
+    docs,
+    tags,
+  })
 }

package/src/add-schedule.ts

@@ -2,11 +2,11 @@ import * as ts from 'typescript'
 import { getPropertyValue } from './get-property-value.js'
 import { APIDocs } from '@pikku/core'
 import { InspectorFilters, InspectorState } from './types.js'
-import { matchesFilters } from './utils.js'
+import { extractFunctionName, matchesFilters } from './utils.js'
 
 export const addSchedule = (
   node: ts.Node,
-  _checker: ts.TypeChecker,
+  checker: ts.TypeChecker,
   state: InspectorState,
   filters: InspectorFilters
 ) => {
@@ -35,6 +35,25 @@ export const addSchedule = (
     const docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
     const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
 
+    // --- find the referenced function ---
+    const funcProp = obj.properties.find(
+      (p) =>
+        ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'func'
+    ) as ts.PropertyAssignment | undefined
+
+    if (!funcProp || !ts.isIdentifier(funcProp.initializer)) {
+      console.error(
+        `• No valid 'func' property for scheduled task '${nameValue}'.`
+      )
+      return
+    }
+    const pikkuFuncName = extractFunctionName(
+      funcProp.initializer,
+      checker
+    ).pikkuFuncName
+
     if (!nameValue || !scheduleValue) {
       return
     }
@@ -46,11 +65,12 @@ export const addSchedule = (
     }
 
     state.scheduledTasks.files.add(node.getSourceFile().fileName)
-    state.scheduledTasks.meta.push({
+    state.scheduledTasks.meta[nameValue] = {
+      pikkuFuncName,
       name: nameValue,
       schedule: scheduleValue,
       docs,
       tags,
-    })
+    }
   }
 }

package/src/inspector.ts

@@ -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'
 import {
   InspectorState,
@@ -31,6 +31,11 @@ export const inspect = (
     singletonServicesFactories: new Map(),
     sessionServicesFactories: new Map(),
     configFactories: new Map(),
+    functions: {
+      typesMap: new TypesMap(),
+      meta: {},
+      files: new Set(),
+    },
     http: {
       typesMap: new TypesMap(),
       metaInputTypes: new Map(),
@@ -41,22 +46,29 @@ export const inspect = (
       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) =>
-      visit(checker, child, state, filters)
+      visitSetup(checker, child, state, filters)
     )
   }
 
-  // Normalise the typesMap
+  // Second sweep: add all transports
+  for (const sourceFile of sourceFiles) {
+    ts.forEachChild(sourceFile, (child) =>
+      visitRoutes(checker, child, state, filters)
+    )
+  }
 
+  // Normalise the typesMap
   state.http = normalizeHTTPTypes(state.http)
 
   return state