@pikku/inspector 0.9.6-next.0 → 0.10.1

package/src/utils/post-process.ts

@@ -0,0 +1,178 @@
+import { InspectorState } from '../types.js'
+import {
+  FunctionServicesMeta,
+  MiddlewareMetadata,
+  PermissionMetadata,
+} from '@pikku/core'
+
+/**
+ * Helper to extract wire-level middleware/permission names from metadata.
+ * Only extracts type:'wire' variants (individual middleware/permissions).
+ * Skips type:'http' and type:'tag' (reference groups, not individuals).
+ */
+export function extractWireNames(
+  list?: MiddlewareMetadata[] | PermissionMetadata[]
+): string[] {
+  if (!list) return []
+  return list
+    .filter(
+      (item): item is { type: 'wire'; name: string } => item.type === 'wire'
+    )
+    .map((item) => item.name)
+}
+
+/**
+ * Helper to expand middleware/permission groups into individual names
+ * and add their services to the aggregation.
+ * This handles tag-based and HTTP-pattern-based middleware/permission groups.
+ */
+function expandAndAddGroupServices(
+  list: MiddlewareMetadata[] | PermissionMetadata[] | undefined,
+  state: InspectorState,
+  addServices: (services: FunctionServicesMeta | undefined) => void,
+  isMiddleware: boolean
+): void {
+  if (!list) return
+
+  for (const item of list) {
+    if (item.type === 'tag') {
+      // Expand tag-based group
+      const groupMeta = isMiddleware
+        ? state.middleware.tagMiddleware.get(item.tag)
+        : state.permissions.tagPermissions.get(item.tag)
+
+      if (groupMeta?.services) {
+        addServices(groupMeta.services)
+      }
+    } else if (item.type === 'http' && 'route' in item) {
+      // Expand HTTP-pattern-based group
+      const groupMeta = isMiddleware
+        ? state.http.routeMiddleware.get(item.route)
+        : state.http.routePermissions.get(item.route)
+
+      if (groupMeta?.services) {
+        addServices(groupMeta.services)
+      }
+    }
+  }
+}
+
+/**
+ * Aggregates all required services from wired functions, middleware, and permissions.
+ * Must be called after AST traversal completes.
+ *
+ * Note: usedFunctions, usedMiddleware, and usedPermissions are tracked directly
+ * in the add-* methods during AST traversal for efficiency.
+ */
+export function aggregateRequiredServices(state: InspectorState): void {
+  const { requiredServices, usedFunctions, usedMiddleware, usedPermissions } =
+    state.serviceAggregation
+
+  // Internal services (always excluded from tree-shaking)
+  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
+
+  const addServices = (services: FunctionServicesMeta | undefined) => {
+    if (!services || !services.services) return
+    services.services.forEach((service) => {
+      if (!internalServices.has(service)) {
+        requiredServices.add(service)
+      }
+    })
+  }
+
+  // 1. Services from used functions
+  usedFunctions.forEach((funcName) => {
+    const funcMeta = state.functions.meta[funcName]
+    if (funcMeta?.services) {
+      addServices(funcMeta.services)
+    }
+  })
+
+  // 2. Services from used middleware (individual + groups)
+  usedMiddleware.forEach((middlewareName) => {
+    const middlewareMeta = state.middleware.meta[middlewareName]
+    if (middlewareMeta?.services) {
+      addServices(middlewareMeta.services)
+    }
+  })
+
+  // 3. Services from used permissions (individual + groups)
+  usedPermissions.forEach((permissionName) => {
+    const permissionMeta = state.permissions.meta[permissionName]
+    if (permissionMeta?.services) {
+      addServices(permissionMeta.services)
+    }
+  })
+
+  // 4. Services from middleware/permission groups used in wirings
+  // We need to check all wirings and expand any tag/HTTP-pattern groups they use
+  for (const method of [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'head',
+    'options',
+  ] as const) {
+    for (const routeMeta of Object.values(state.http.meta[method])) {
+      expandAndAddGroupServices(routeMeta.middleware, state, addServices, true)
+      expandAndAddGroupServices(
+        routeMeta.permissions,
+        state,
+        addServices,
+        false
+      )
+    }
+  }
+
+  // Also check other wiring types (channels, queues, schedulers, MCP)
+  for (const channelMeta of Object.values(state.channels.meta)) {
+    expandAndAddGroupServices(channelMeta.middleware, state, addServices, true)
+    expandAndAddGroupServices(
+      channelMeta.permissions,
+      state,
+      addServices,
+      false
+    )
+  }
+
+  for (const queueMeta of Object.values(state.queueWorkers.meta)) {
+    expandAndAddGroupServices(queueMeta.middleware, state, addServices, true)
+    // expandAndAddGroupServices(queueMeta.permissions, state, addServices, false)
+  }
+
+  for (const scheduleMeta of Object.values(state.scheduledTasks.meta)) {
+    expandAndAddGroupServices(scheduleMeta.middleware, state, addServices, true)
+    // expandAndAddGroupServices(scheduleMeta.permissions, state, addServices, false)
+  }
+
+  for (const toolMeta of Object.values(state.mcpEndpoints.toolsMeta)) {
+    expandAndAddGroupServices(toolMeta.middleware, state, addServices, true)
+    expandAndAddGroupServices(toolMeta.permissions, state, addServices, false)
+  }
+
+  for (const promptMeta of Object.values(state.mcpEndpoints.promptsMeta)) {
+    expandAndAddGroupServices(promptMeta.middleware, state, addServices, true)
+    expandAndAddGroupServices(promptMeta.permissions, state, addServices, false)
+  }
+
+  for (const resourceMeta of Object.values(state.mcpEndpoints.resourcesMeta)) {
+    expandAndAddGroupServices(resourceMeta.middleware, state, addServices, true)
+    expandAndAddGroupServices(
+      resourceMeta.permissions,
+      state,
+      addServices,
+      false
+    )
+  }
+
+  // 5. Services from session service factories
+  for (const singletonServices of state.sessionServicesMeta.values()) {
+    singletonServices.forEach((service) => {
+      if (!internalServices.has(service)) {
+        requiredServices.add(service)
+      }
+    })
+  }
+}

package/src/utils/serialize-inspector-state.ts

@@ -0,0 +1,375 @@
+import { InspectorState } from '../types.js'
+import { TypesMap } from '../types-map.js'
+
+/**
+ * Serializable version of InspectorState that can be saved to JSON
+ * Omits typesLookup (contains non-serializable ts.Type objects) and converts Maps/Sets to arrays
+ */
+export interface SerializableInspectorState {
+  rootDir: string
+  singletonServicesTypeImportMap: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  sessionServicesTypeImportMap: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  userSessionTypeImportMap: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  configTypeImportMap: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  singletonServicesFactories: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  sessionServicesFactories: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  sessionServicesMeta: Array<[string, string[]]>
+  configFactories: Array<
+    [
+      string,
+      { variable: string; type: string | null; typePath: string | null }[],
+    ]
+  >
+  filesAndMethods: InspectorState['filesAndMethods']
+  filesAndMethodsErrors: Array<
+    [
+      string,
+      Array<
+        [
+          string,
+          { variable: string; type: string | null; typePath: string | null }[],
+        ]
+      >,
+    ]
+  >
+  functions: {
+    typesMap: {
+      map: Array<[string, { originalName: string; path: string | null }]>
+      customTypes: Array<[string, { type: string; references: string[] }]>
+    }
+    meta: InspectorState['functions']['meta']
+    files: Array<[string, { path: string; exportedName: string }]>
+  }
+  http: {
+    metaInputTypes: Array<
+      [
+        string,
+        {
+          query: string[] | undefined
+          params: string[] | undefined
+          body: string[] | undefined
+        },
+      ]
+    >
+    meta: InspectorState['http']['meta']
+    files: string[]
+    routeMiddleware: Array<
+      [
+        string,
+        InspectorState['http']['routeMiddleware'] extends Map<string, infer V>
+          ? V
+          : never,
+      ]
+    >
+    routePermissions: Array<
+      [
+        string,
+        InspectorState['http']['routePermissions'] extends Map<string, infer V>
+          ? V
+          : never,
+      ]
+    >
+  }
+  channels: {
+    files: string[]
+    meta: InspectorState['channels']['meta']
+  }
+  scheduledTasks: {
+    meta: InspectorState['scheduledTasks']['meta']
+    files: string[]
+  }
+  queueWorkers: {
+    meta: InspectorState['queueWorkers']['meta']
+    files: string[]
+  }
+  rpc: {
+    internalMeta: InspectorState['rpc']['internalMeta']
+    internalFiles: Array<[string, { path: string; exportedName: string }]>
+    exposedMeta: InspectorState['rpc']['exposedMeta']
+    exposedFiles: Array<[string, { path: string; exportedName: string }]>
+    invokedFunctions: string[]
+  }
+  mcpEndpoints: {
+    resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta']
+    toolsMeta: InspectorState['mcpEndpoints']['toolsMeta']
+    promptsMeta: InspectorState['mcpEndpoints']['promptsMeta']
+    files: string[]
+  }
+  cli: {
+    meta: InspectorState['cli']['meta']
+    files: string[]
+  }
+  middleware: {
+    meta: InspectorState['middleware']['meta']
+    tagMiddleware: Array<
+      [
+        string,
+        InspectorState['middleware']['tagMiddleware'] extends Map<
+          string,
+          infer V
+        >
+          ? V
+          : never,
+      ]
+    >
+  }
+  permissions: {
+    meta: InspectorState['permissions']['meta']
+    tagPermissions: Array<
+      [
+        string,
+        InspectorState['permissions']['tagPermissions'] extends Map<
+          string,
+          infer V
+        >
+          ? V
+          : never,
+      ]
+    >
+  }
+  serviceAggregation: {
+    requiredServices: string[]
+    usedFunctions: string[]
+    usedMiddleware: string[]
+    usedPermissions: string[]
+  }
+}
+
+/**
+ * Serializes InspectorState to a JSON-compatible format
+ * Omits typesLookup (not needed for filtering/generation) and converts Maps/Sets to arrays
+ */
+export function serializeInspectorState(
+  state: InspectorState
+): SerializableInspectorState {
+  // Helper to serialize TypesMap
+  const serializeTypesMap = (
+    typesMap: TypesMap
+  ): {
+    map: Array<[string, { originalName: string; path: string | null }]>
+    customTypes: Array<[string, { type: string; references: string[] }]>
+  } => {
+    // Access private map via type assertion
+    const mapEntries: Array<
+      [string, { originalName: string; path: string | null }]
+    > = Array.from((typesMap as any).map.entries())
+    const customTypesEntries: Array<
+      [string, { type: string; references: string[] }]
+    > = Array.from(typesMap.customTypes.entries())
+
+    return {
+      map: mapEntries,
+      customTypes: customTypesEntries,
+    }
+  }
+
+  return {
+    rootDir: state.rootDir,
+    singletonServicesTypeImportMap: Array.from(
+      state.singletonServicesTypeImportMap.entries()
+    ),
+    sessionServicesTypeImportMap: Array.from(
+      state.sessionServicesTypeImportMap.entries()
+    ),
+    userSessionTypeImportMap: Array.from(
+      state.userSessionTypeImportMap.entries()
+    ),
+    configTypeImportMap: Array.from(state.configTypeImportMap.entries()),
+    singletonServicesFactories: Array.from(
+      state.singletonServicesFactories.entries()
+    ),
+    sessionServicesFactories: Array.from(
+      state.sessionServicesFactories.entries()
+    ),
+    sessionServicesMeta: Array.from(state.sessionServicesMeta.entries()),
+    configFactories: Array.from(state.configFactories.entries()),
+    filesAndMethods: state.filesAndMethods,
+    filesAndMethodsErrors: Array.from(
+      state.filesAndMethodsErrors.entries()
+    ).map(([key, mapValue]) => [key, Array.from(mapValue.entries())] as const),
+    functions: {
+      typesMap: serializeTypesMap(state.functions.typesMap),
+      meta: state.functions.meta,
+      files: Array.from(state.functions.files.entries()),
+    },
+    http: {
+      metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
+      meta: state.http.meta,
+      files: Array.from(state.http.files),
+      routeMiddleware: Array.from(state.http.routeMiddleware.entries()),
+      routePermissions: Array.from(state.http.routePermissions.entries()),
+    },
+    channels: {
+      files: Array.from(state.channels.files),
+      meta: state.channels.meta,
+    },
+    scheduledTasks: {
+      meta: state.scheduledTasks.meta,
+      files: Array.from(state.scheduledTasks.files),
+    },
+    queueWorkers: {
+      meta: state.queueWorkers.meta,
+      files: Array.from(state.queueWorkers.files),
+    },
+    rpc: {
+      internalMeta: state.rpc.internalMeta,
+      internalFiles: Array.from(state.rpc.internalFiles.entries()),
+      exposedMeta: state.rpc.exposedMeta,
+      exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
+      invokedFunctions: Array.from(state.rpc.invokedFunctions),
+    },
+    mcpEndpoints: {
+      resourcesMeta: state.mcpEndpoints.resourcesMeta,
+      toolsMeta: state.mcpEndpoints.toolsMeta,
+      promptsMeta: state.mcpEndpoints.promptsMeta,
+      files: Array.from(state.mcpEndpoints.files),
+    },
+    cli: {
+      meta: state.cli.meta,
+      files: Array.from(state.cli.files),
+    },
+    middleware: {
+      meta: state.middleware.meta,
+      tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
+    },
+    permissions: {
+      meta: state.permissions.meta,
+      tagPermissions: Array.from(state.permissions.tagPermissions.entries()),
+    },
+    serviceAggregation: {
+      requiredServices: Array.from(state.serviceAggregation.requiredServices),
+      usedFunctions: Array.from(state.serviceAggregation.usedFunctions),
+      usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
+      usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
+    },
+  }
+}
+
+/**
+ * Deserializes JSON data back to InspectorState
+ * Creates a partial state suitable for filtering/generation (without typesLookup)
+ */
+export function deserializeInspectorState(
+  data: SerializableInspectorState
+): Omit<InspectorState, 'typesLookup'> {
+  // Helper to deserialize TypesMap
+  const deserializeTypesMap = (
+    serialized: SerializableInspectorState['functions']['typesMap']
+  ): TypesMap => {
+    const typesMap = new TypesMap()
+
+    // Restore private map
+    ;(typesMap as any).map = new Map(serialized.map)
+
+    // Restore public customTypes
+    typesMap.customTypes = new Map(serialized.customTypes)
+
+    return typesMap
+  }
+
+  return {
+    rootDir: data.rootDir,
+    singletonServicesTypeImportMap: new Map(
+      data.singletonServicesTypeImportMap
+    ),
+    sessionServicesTypeImportMap: new Map(data.sessionServicesTypeImportMap),
+    userSessionTypeImportMap: new Map(data.userSessionTypeImportMap),
+    configTypeImportMap: new Map(data.configTypeImportMap),
+    singletonServicesFactories: new Map(data.singletonServicesFactories),
+    sessionServicesFactories: new Map(data.sessionServicesFactories),
+    sessionServicesMeta: new Map(data.sessionServicesMeta),
+    configFactories: new Map(data.configFactories),
+    filesAndMethods: data.filesAndMethods,
+    filesAndMethodsErrors: new Map(
+      data.filesAndMethodsErrors.map(([key, entries]) => [
+        key,
+        new Map(entries),
+      ])
+    ),
+    functions: {
+      typesMap: deserializeTypesMap(data.functions.typesMap),
+      meta: data.functions.meta,
+      files: new Map(data.functions.files),
+    },
+    http: {
+      metaInputTypes: new Map(data.http.metaInputTypes),
+      meta: data.http.meta,
+      files: new Set(data.http.files),
+      routeMiddleware: new Map(data.http.routeMiddleware),
+      routePermissions: new Map(data.http.routePermissions),
+    },
+    channels: {
+      files: new Set(data.channels.files),
+      meta: data.channels.meta,
+    },
+    scheduledTasks: {
+      meta: data.scheduledTasks.meta,
+      files: new Set(data.scheduledTasks.files),
+    },
+    queueWorkers: {
+      meta: data.queueWorkers.meta,
+      files: new Set(data.queueWorkers.files),
+    },
+    rpc: {
+      internalMeta: data.rpc.internalMeta,
+      internalFiles: new Map(data.rpc.internalFiles),
+      exposedMeta: data.rpc.exposedMeta,
+      exposedFiles: new Map(data.rpc.exposedFiles),
+      invokedFunctions: new Set(data.rpc.invokedFunctions),
+    },
+    mcpEndpoints: {
+      resourcesMeta: data.mcpEndpoints.resourcesMeta,
+      toolsMeta: data.mcpEndpoints.toolsMeta,
+      promptsMeta: data.mcpEndpoints.promptsMeta,
+      files: new Set(data.mcpEndpoints.files),
+    },
+    cli: {
+      meta: data.cli.meta,
+      files: new Set(data.cli.files),
+    },
+    middleware: {
+      meta: data.middleware.meta,
+      tagMiddleware: new Map(data.middleware.tagMiddleware),
+    },
+    permissions: {
+      meta: data.permissions.meta,
+      tagPermissions: new Map(data.permissions.tagPermissions),
+    },
+    serviceAggregation: {
+      requiredServices: new Set(data.serviceAggregation.requiredServices),
+      usedFunctions: new Set(data.serviceAggregation.usedFunctions),
+      usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
+      usedPermissions: new Set(data.serviceAggregation.usedPermissions),
+    },
+  }
+}