@pikku/inspector 0.7.0 → 0.7.1

package/src/index.ts

@@ -0,0 +1,4 @@
+export { inspect } from './inspector.js'
+export type { TypesMap } from './types-map.js'
+export type * from './types.js'
+export type { InspectorState } from './types.js'

package/src/inspector.ts

@@ -0,0 +1,75 @@
+import * as ts from 'typescript'
+import { visitSetup, visitRoutes } from './visit.js'
+import { TypesMap } from './types-map.js'
+import {
+  InspectorState,
+  InspectorHTTPState,
+  InspectorFilters,
+} from './types.js'
+
+export const normalizeHTTPTypes = (
+  httpState: InspectorHTTPState
+): InspectorHTTPState => {
+  return httpState
+}
+
+export const inspect = (
+  routeFiles: string[],
+  filters: InspectorFilters
+): InspectorState => {
+  const program = ts.createProgram(routeFiles, {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.CommonJS,
+  })
+  const checker = program.getTypeChecker()
+  const sourceFiles = program.getSourceFiles()
+
+  const state: InspectorState = {
+    singletonServicesTypeImportMap: new Map(),
+    sessionServicesTypeImportMap: new Map(),
+    userSessionTypeImportMap: new Map(),
+    singletonServicesFactories: new Map(),
+    sessionServicesFactories: new Map(),
+    configFactories: new Map(),
+    functions: {
+      typesMap: new TypesMap(),
+      meta: {},
+      files: new Set(),
+    },
+    http: {
+      typesMap: new TypesMap(),
+      metaInputTypes: new Map(),
+      meta: [],
+      files: new Set(),
+    },
+    channels: {
+      typesMap: new TypesMap(),
+      metaInputTypes: new Map(),
+      files: new Set(),
+      meta: {},
+    },
+    scheduledTasks: {
+      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) =>
+      visitRoutes(checker, child, state, filters)
+    )
+  }
+
+  // Normalise the typesMap
+  state.http = normalizeHTTPTypes(state.http)
+
+  return state
+}

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'
+import { FunctionsMeta } from '@pikku/core'
+
+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 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
+  meta: ChannelsMeta
+  files: Set<string>
+}
+
+export type InspectorFilters = {
+  tags?: string[]
+}
+export interface InspectorState {
+  singletonServicesTypeImportMap: PathToNameAndType
+  sessionServicesTypeImportMap: PathToNameAndType
+  userSessionTypeImportMap: PathToNameAndType
+  singletonServicesFactories: PathToNameAndType
+  sessionServicesFactories: PathToNameAndType
+  configFactories: PathToNameAndType
+  http: InspectorHTTPState
+  functions: InspectorFunctionState
+  channels: InspectorChannelState
+  scheduledTasks: {
+    meta: ScheduledTasksMeta
+    files: Set<string>
+  }
+}