@pikku/inspector 0.6.2

package/src/types-map.ts

@@ -0,0 +1,130 @@
+export class TypesMap {
+  private map: Map<string, { originalName: string; path: string | null }> =
+    new Map()
+  public customTypes: Map<string, { type: string; references: string[] }> =
+    new Map()
+
+  public addCustomType(name: string, type: string, references: string[]) {
+    this.customTypes.set(name, { type, references })
+  }
+
+  public addType(originalName: string, path: string) {
+    this.map.set(originalName, { originalName, path })
+  }
+
+  public addUniqueType(originalName: string, path: string): string {
+    const uniqueName = `${originalName}_${Math.random().toString(36).substring(7)}`
+    this.map.set(uniqueName, { originalName, path })
+    return uniqueName
+  }
+
+  public getUniqueName(name: string): string {
+    const meta = this.getTypeMeta(name)
+    return meta.uniqueName
+  }
+
+  public getTypeMeta(name: string): {
+    originalName: string
+    uniqueName: string
+    path: string | null
+  } {
+    if (['string', 'number', 'boolean', 'null'].includes(name)) {
+      return {
+        originalName: name,
+        uniqueName: name,
+        path: null,
+      }
+    }
+
+    if (this.customTypes.has(name)) {
+      return {
+        originalName: name,
+        uniqueName: name,
+        path: null,
+      }
+    }
+
+    let meta = this.map.get(name)
+    if (!meta) {
+      meta = Array.from(this.map.entries()).find(
+        ([_, { originalName }]) => originalName === name
+      )?.[1]
+    }
+    if (!meta) {
+      throw new Error(`Type ${name} not found in typesMap`)
+    }
+
+    const getName = this.squash()
+    return {
+      uniqueName: getName(name),
+      originalName: meta.originalName,
+      path: meta?.path,
+    }
+  }
+
+  public exists(originalName: string, path: string): string | undefined {
+    const found = Array.from(this.map.entries()).find(([_, type]) => {
+      return type.path === path && type.originalName === originalName
+    })
+    return found ? found[0] : undefined
+  }
+
+  private squash() {
+    const duplicateNames = new Set<string>()
+    const pathToNamesMap = new Map<string, Map<string, string>>()
+    const nameOccurrences = new Map<string, Set<string>>()
+
+    // First pass: Track occurrences of each original name across paths
+    this.map.forEach(({ path, originalName }) => {
+      if (path) {
+        if (!nameOccurrences.has(originalName)) {
+          nameOccurrences.set(originalName, new Set())
+        }
+        nameOccurrences.get(originalName)!.add(path)
+      }
+    })
+
+    // Second pass: Populate pathToNamesMap
+    this.map.forEach(({ path, originalName }, uniqueName) => {
+      if (!path) return
+
+      if (!pathToNamesMap.has(path)) {
+        pathToNamesMap.set(path, new Map())
+      }
+
+      const isDuplicate = nameOccurrences.get(originalName)!.size > 1
+      if (isDuplicate) {
+        duplicateNames.add(uniqueName)
+      }
+      // Use uniqueName only if the originalName is duplicated across files
+      const nameToUse = isDuplicate ? uniqueName : originalName
+      pathToNamesMap.get(path)!.set(nameToUse, originalName)
+    })
+
+    const getName = (uniqueName: string) => {
+      if (duplicateNames.has(uniqueName)) {
+        return uniqueName
+      }
+      if (
+        uniqueName === 'string' ||
+        uniqueName === 'number' ||
+        uniqueName === 'boolean' ||
+        uniqueName === 'null'
+      ) {
+        return uniqueName
+      }
+      if (!this.map.has(uniqueName)) {
+        const found = Array.from(this.map.entries()).find(
+          ([_, { originalName }]) => originalName === uniqueName
+        )?.[1]
+        if (!found) {
+          throw new Error(`Type ${uniqueName} not found in typesMap`)
+        }
+        return found.originalName
+      }
+      return this.map.get(uniqueName)!.originalName
+    }
+
+    return getName
+  }
+}

package/src/types.ts

@@ -0,0 +1,58 @@
+import { ChannelsMeta } from '@pikku/core/channel'
+import { HTTPRoutesMeta } from '@pikku/core/http'
+import { ScheduledTasksMeta } from '@pikku/core/scheduler'
+import { TypesMap } from './types-map.js'
+
+export type PathToNameAndType = Map<
+  string,
+  { variable: string; type: string | null; typePath: string | null }[]
+>
+
+export type MetaInputTypes = Map<
+  string,
+  {
+    query: string[] | undefined
+    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 InspectorChannelState {
+  typesMap: TypesMap
+  metaInputTypes: MetaInputTypes
+  meta: ChannelsMeta
+  files: Set<string>
+}
+
+export interface InspectorState {
+  sessionServicesTypeImportMap: PathToNameAndType
+  userSessionTypeImportMap: PathToNameAndType
+  singletonServicesFactories: PathToNameAndType
+  sessionServicesFactories: PathToNameAndType
+  configFactories: PathToNameAndType
+  http: InspectorHTTPState
+  channels: InspectorChannelState
+  scheduledTasks: {
+    meta: ScheduledTasksMeta
+    files: Set<string>
+  }
+}

package/src/utils.ts

@@ -0,0 +1,349 @@
+import * as ts from 'typescript'
+import { TypesMap } from './types-map.js'
+
+type FunctionTypes = {
+  inputTypes: ts.Type[]
+  inputs: null | string[]
+  outputTypes: ts.Type[]
+  outputs: null | string[]
+}
+
+export const extractTypeKeys = (type: ts.Type): string[] => {
+  return type.getProperties().map((symbol) => symbol.getName())
+}
+
+export const nullifyTypes = (type: string | null) => {
+  if (
+    type === 'void' ||
+    type === 'undefined' ||
+    type === 'unknown' ||
+    type === 'any'
+  ) {
+    return null
+  }
+  return type
+}
+
+const isValidVariableName = (name: string) => {
+  const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
+  return regex.test(name)
+}
+
+export const getNamesAndTypes = (
+  checker: ts.TypeChecker,
+  typesMap: TypesMap,
+  direction: 'Input' | 'Output',
+  funcName: string,
+  type: ts.Type
+) => {
+  const result: {
+    names: Set<string>
+    types: ts.Type[]
+  } = {
+    names: new Set(),
+    types: [],
+  }
+
+  const { names, types } = resolveUnionTypes(checker, type)
+  const firstName = names[0]
+  if (names.length > 1 || (firstName && !isValidVariableName(firstName))) {
+    const aliasType = names.join(' | ')
+    const aliasName = `${funcName.charAt(0).toUpperCase()}${funcName.slice(1)}${direction}`
+
+    result.names = new Set([aliasName])
+    result.types = types
+
+    const references = types
+      .map((t) => resolveTypeImports(t, typesMap, true))
+      .flat()
+    typesMap.addCustomType(aliasName, aliasType, references)
+  } else {
+    const uniqueNames = names
+      .map((name, i) => {
+        const type = types[i]
+        if (!type) {
+          throw new Error('TODO: Expected a type here to match name')
+        }
+        if (isPrimitiveType(type)) {
+          return name
+        }
+        return resolveTypeImports(type, typesMap, false)
+      })
+      .flat()
+    result.names = new Set(uniqueNames)
+    result.types = types
+  }
+
+  return {
+    names: Array.from(result.names),
+    types: result.types,
+  }
+}
+
+export 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
+
+  return (type.flags & primitiveFlags) !== 0
+}
+
+export 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 }
+}
+
+export 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
+}
+
+export const getPropertyAssignment = (
+  obj: ts.ObjectLiteralExpression,
+  name: string
+) => {
+  const property = obj.properties.find(
+    (p) =>
+      (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === name
+  )
+  if (!property) {
+    console.error(`Missing property '${name}' in object`)
+    return null
+  }
+  return property
+}
+
+export const getTypeArgumentsOfType = (
+  checker: ts.TypeChecker,
+  type: ts.Type
+): readonly ts.Type[] | null => {
+  if (type.isUnionOrIntersection()) {
+    const types: ts.Type[] = []
+    for (const subType of type.types) {
+      const subTypeArgs = getTypeArgumentsOfType(checker, subType)
+      if (subTypeArgs) {
+        types.push(...subTypeArgs)
+      }
+    }
+    return types.length > 0 ? types : null
+  }
+
+  // If the type is a TypeReference with typeArguments, return them
+  if (
+    type.flags & ts.TypeFlags.Object &&
+    (type as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference
+  ) {
+    const typeRef = type as ts.TypeReference
+    if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+      return typeRef.typeArguments
+    }
+  }
+
+  // If the type is an alias with aliasTypeArguments, return them
+  if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
+    return type.aliasTypeArguments as ts.Type[]
+  }
+
+  return null
+}
+
+export const getFunctionTypes = (
+  checker: ts.TypeChecker,
+  obj: ts.ObjectLiteralExpression,
+  {
+    typesMap,
+    funcName,
+    subFunctionName = funcName,
+    inputIndex,
+    outputIndex,
+  }: {
+    typesMap: TypesMap
+    subFunctionName?: string
+    funcName: string
+    inputIndex: number
+    outputIndex: number
+  }
+): FunctionTypes => {
+  const result: FunctionTypes = {
+    inputTypes: [],
+    inputs: null,
+    outputTypes: [],
+    outputs: null,
+  }
+
+  const property = getPropertyAssignment(obj, subFunctionName)
+  if (!property) {
+    return result
+  }
+
+  let type: ts.Type | undefined
+
+  // Handle shorthand property assignment
+  if (ts.isShorthandPropertyAssignment(property)) {
+    const symbol = checker.getShorthandAssignmentValueSymbol(property)
+    if (symbol) {
+      type = checker.getTypeOfSymbolAtLocation(symbol, property)
+      if (funcName === 'func') {
+        funcName = symbol.name
+      }
+    }
+  }
+  // Handle regular property assignment
+  else if (ts.isPropertyAssignment(property)) {
+    if (ts.isObjectLiteralExpression(property.initializer)) {
+      return getFunctionTypes(checker, property.initializer, {
+        typesMap,
+        funcName,
+        subFunctionName: 'func',
+        inputIndex,
+        outputIndex,
+      })
+    }
+
+    if (property.initializer) {
+      type = checker.getTypeAtLocation(property.initializer)
+      if (funcName === 'func') {
+        funcName = property.initializer.getText()
+      }
+    }
+  }
+
+  if (!type) {
+    console.error(`Unable to resolve type for property '${funcName}'`)
+    return result
+  }
+
+  // Access type arguments from TypeReference
+  const typeArguments = getTypeArgumentsOfType(checker, type)
+
+  if (!typeArguments || typeArguments.length === 0) {
+    // This is the case for inline functions. In this case we would want to
+    // get the types from the second argument of the function...
+    console.error(
+      `\x1b[31m• No generic type arguments found for ${funcName}. Support for inline functions is not yet implemented.\x1b[0m`
+    )
+    return result
+  }
+
+  if (inputIndex !== undefined && inputIndex < typeArguments.length) {
+    const { names, types } = getNamesAndTypes(
+      checker,
+      typesMap,
+      'Input',
+      funcName,
+      typeArguments[inputIndex]!
+    )
+    result.inputs = names
+    result.inputTypes = types
+  } else {
+    console.log(`No input defined for ${funcName}`)
+  }
+
+  if (outputIndex !== undefined && outputIndex < typeArguments.length) {
+    const { names, types } = getNamesAndTypes(
+      checker,
+      typesMap,
+      'Output',
+      funcName,
+      typeArguments[outputIndex]!
+    )
+    result.outputs = names
+    result.outputTypes = types
+  } else {
+    console.info(`No output defined for ${funcName}`)
+  }
+
+  return result
+}

package/src/visit.ts

@@ -0,0 +1,49 @@
+import * as ts from 'typescript'
+import { addFileWithFactory } from './add-file-with-factory.js'
+import { addFileExtendsCoreType } from './add-file-extends-core-type.js'
+import { addRoute } from './add-route.js'
+import { addSchedule } from './add-schedule.js'
+import { addChannel } from './add-channel.js'
+import { InspectorState } from './types.js'
+
+export const visit = (
+  checker: ts.TypeChecker,
+  node: ts.Node,
+  state: InspectorState
+) => {
+  addFileExtendsCoreType(
+    node,
+    checker,
+    state.sessionServicesTypeImportMap,
+    'CoreServices'
+  )
+
+  addFileExtendsCoreType(
+    node,
+    checker,
+    state.userSessionTypeImportMap,
+    'CoreUserSession'
+  )
+
+  addFileWithFactory(
+    node,
+    checker,
+    state.singletonServicesFactories,
+    'CreateSingletonServices'
+  )
+
+  addFileWithFactory(
+    node,
+    checker,
+    state.sessionServicesFactories,
+    'CreateSessionServices'
+  )
+
+  addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
+
+  addRoute(node, checker, state)
+  addSchedule(node, checker, state)
+  addChannel(node, checker, state)
+
+  ts.forEachChild(node, (child) => visit(checker, child, state))
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "module": "Node16",
+    "outDir": "dist",
+    "target": "esnext",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "composite": true
+  },
+  "include": ["bin/**/*.ts", "src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
+  "references": [
+    {
+      "path": "../core/tsconfig.json"
+    }
+  ]
+}