@pikku/inspector 0.12.7 → 0.12.9

package/src/utils/resolve-versions.test.ts

@@ -215,6 +215,147 @@ describe('resolveLatestVersions', () => {
     assert.strictEqual(errors.length, 0)
   })
 
+  test('exposedMeta propagates all versions when base name is exposed', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    state.rpc.exposedMeta['createUser'] = 'createUser'
+    state.rpc.internalFiles.set('createUser@v1', {
+      path: '/src/user.ts',
+      exportedName: 'createUserV1',
+    })
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(state.rpc.exposedMeta['createUser'], 'createUser@v2')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v1'], 'createUser@v1')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v2'], 'createUser@v2')
+  })
+
+  test('exposedFiles propagated for versioned exposed functions', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    state.rpc.exposedMeta['createUser'] = 'createUser'
+    state.rpc.internalFiles.set('createUser@v1', {
+      path: '/src/user-v1.ts',
+      exportedName: 'createUserV1',
+    })
+    state.rpc.internalFiles.set('createUser', {
+      path: '/src/user.ts',
+      exportedName: 'createUser',
+    })
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.ok(state.rpc.exposedFiles.has('createUser@v1'))
+    assert.strictEqual(
+      state.rpc.exposedFiles.get('createUser@v1')!.exportedName,
+      'createUserV1'
+    )
+    assert.ok(state.rpc.exposedFiles.has('createUser@v2'))
+  })
+
+  test('exposedMeta unchanged when base name is not exposed', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v1'], undefined)
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v2'], undefined)
+  })
+
+  test('exposedMeta propagates when only explicit versions exist', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      'createUser@v2': {
+        pikkuFuncId: 'createUser@v2',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 2,
+      },
+    })
+    state.rpc.exposedMeta['createUser'] = 'createUser@v1'
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(state.rpc.exposedMeta['createUser'], 'createUser@v2')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v1'], 'createUser@v1')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v2'], 'createUser@v2')
+  })
+
+  test('updates HTTP meta pikkuFuncId when renaming unversioned', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    ;(state as any).http = {
+      meta: {
+        post: {
+          '/api/users': { pikkuFuncId: 'createUser', route: '/api/users' },
+        },
+      },
+    }
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(
+      (state as any).http.meta.post['/api/users'].pikkuFuncId,
+      'createUser@v2'
+    )
+  })
+
   test('renames files entries when renaming unversioned to versioned', () => {
     const state = makeState({
       'createUser@v1': {

package/src/utils/resolve-versions.ts

@@ -91,6 +91,8 @@ export function resolveLatestVersions(
       if (state.rpc.exposedMeta[baseName] === oldId) {
         state.rpc.exposedMeta[baseName] = newId
       }
+
+      updateWiringReferences(state, oldId, newId)
     } else {
       const latest = group.explicit.reduce((a, b) =>
         a.version > b.version ? a : b
@@ -98,8 +100,43 @@ export function resolveLatestVersions(
       state.rpc.internalMeta[baseName] = latest.id
     }
 
+    if (state.rpc.exposedMeta[baseName]) {
+      const latestId = state.rpc.internalMeta[baseName]!
+      state.rpc.exposedMeta[baseName] = latestId
+      for (const entry of group.explicit) {
+        state.rpc.exposedMeta[entry.id] = entry.id
+        const fileEntry = state.rpc.internalFiles.get(entry.id)
+        if (fileEntry) {
+          state.rpc.exposedFiles.set(entry.id, fileEntry)
+        }
+      }
+      if (group.unversioned) {
+        state.rpc.exposedMeta[latestId] = latestId
+        const fileEntry = state.rpc.internalFiles.get(latestId)
+        if (fileEntry) {
+          state.rpc.exposedFiles.set(latestId, fileEntry)
+        }
+      }
+    }
+
     for (const entry of group.explicit) {
       state.rpc.invokedFunctions.add(entry.id)
     }
   }
 }
+
+function updateWiringReferences(
+  state: InspectorState,
+  oldId: string,
+  newId: string
+): void {
+  if (state.http) {
+    for (const methods of Object.values(state.http.meta)) {
+      for (const meta of Object.values(methods)) {
+        if (meta.pikkuFuncId === oldId) {
+          meta.pikkuFuncId = newId
+        }
+      }
+    }
+  }
+}

package/src/utils/schema-generator.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript'
 import { dirname, join, resolve } from 'path'
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { tsImport } from 'tsx/esm/api'
+import { register, tsImport } from 'tsx/esm/api'
 import * as z from 'zod'
 import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts'
 import type { FunctionsMeta, JSONValue } from '@pikku/core'
@@ -60,6 +60,10 @@ function primitiveTypeToSchema(typeStr: string): JSONValue | null {
     return { type: 'null' }
   }
 
+  if (normalized === 'any' || normalized === 'unknown') {
+    return {}
+  }
+
   return null
 }
 
@@ -145,7 +149,7 @@ function generateTSSchemas(
   httpWiringsMeta: HTTPWiringsMeta,
   additionalTypes?: string[],
   additionalProperties: boolean = false,
-  schemaLookup?: Map<string, SchemaRef>
+  generatedZodSchemas?: Record<string, JSONValue>
 ): Record<string, JSONValue> {
   const schemasSet = new Set(typesMap.customTypes.keys())
   for (const { inputs, outputs } of Object.values(functionMeta)) {
@@ -182,6 +186,19 @@ function generateTSSchemas(
     }
   }
 
+  // Skip ts-json-schema-generator if all schemas are already covered by Zod/primitives.
+  // Use generatedZodSchemas (actually converted) rather than schemaLookup (all attempted)
+  // so that failed Zod conversions fall through to TS schema generation.
+  const uncoveredSchemas = [...schemasSet].filter(
+    (s) => !PRIMITIVE_TYPES.has(s) && !generatedZodSchemas?.[s]
+  )
+  if (uncoveredSchemas.length === 0) {
+    return {}
+  }
+  logger.debug(
+    `generateTSSchemas needed for ${uncoveredSchemas.length} types: ${uncoveredSchemas.slice(0, 3).join(', ')}${uncoveredSchemas.length > 3 ? '...' : ''}`
+  )
+
   const virtualFilePath = join(
     dirname(resolve(tsconfig)),
     '__pikku_virtual_types__.ts'
@@ -210,7 +227,7 @@ function generateTSSchemas(
     if (PRIMITIVE_TYPES.has(schema)) {
       return
     }
-    if (schemaLookup?.has(schema)) {
+    if (generatedZodSchemas?.[schema]) {
       return
     }
     try {
@@ -236,6 +253,97 @@ function generateTSSchemas(
   return schemas
 }
 
+/**
+ * Import all source files in parallel using tsx's register() API.
+ *
+ * tsx's register() sets up the TypeScript loader once, then all subsequent
+ * import() calls reuse that loader. This is dramatically faster than calling
+ * tsImport() per-file because tsImport() sets up and tears down a fresh
+ * compilation context for each call (~170ms each).
+ *
+ * With register() + parallel import():
+ *   - 71 files: ~350ms total
+ *   - vs tsImport loop: ~12,000ms (71 * 170ms)
+ *
+ * Falls back to serial tsImport() per-file if register() is unavailable.
+ */
+async function batchImportWithRegister(
+  logger: InspectorLogger,
+  sourceFiles: string[]
+): Promise<Map<string, Record<string, any>> | null> {
+  if (sourceFiles.length === 0) return new Map()
+
+  let unregister: (() => void) | undefined
+  try {
+    unregister = register()
+
+    const modules = new Map<string, Record<string, any>>()
+    const results = await Promise.allSettled(
+      sourceFiles.map(async (srcPath) => {
+        const mod = await import(srcPath)
+        modules.set(srcPath, mod)
+      })
+    )
+
+    const failures = results.filter((r) => r.status === 'rejected')
+    if (failures.length > 0) {
+      logger.debug(
+        `${failures.length}/${sourceFiles.length} files failed to import via register()`
+      )
+    }
+
+    return modules
+  } catch (e) {
+    logger.debug(`tsx register() batch import failed: ${(e as Error).message}`)
+    return null
+  } finally {
+    unregister?.()
+  }
+}
+
+function processZodSchema(
+  schemaName: string,
+  zodSchema: any,
+  schemas: Record<string, JSONValue>,
+  typesMap: TypesMap,
+  auxiliaryTypeStore: ReturnType<typeof createAuxiliaryTypeStore>,
+  printer: ts.Printer,
+  fakeSourceFile: ts.SourceFile,
+  logger: InspectorLogger
+): void {
+  const schema = z.toJSONSchema(zodSchema, {
+    unrepresentable: 'any',
+    override: ({ zodSchema, jsonSchema }) => {
+      if ((zodSchema as any)._zod?.def?.type === 'date') {
+        ;(jsonSchema as any).type = 'string'
+        ;(jsonSchema as any).format = 'date-time'
+      }
+    },
+  }) as any
+
+  if (schema.required && schema.properties) {
+    schema.required = schema.required.filter((fieldName: string) => {
+      const prop = schema.properties[fieldName]
+      return prop && prop.default === undefined
+    })
+    if (schema.required.length === 0) {
+      delete schema.required
+    }
+  }
+
+  const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore })
+
+  const typeText = printer.printNode(
+    ts.EmitHint.Unspecified,
+    tsType,
+    fakeSourceFile
+  )
+
+  typesMap.addCustomType(schemaName, typeText, [])
+  schemas[schemaName] = schema
+  logger.debug(`• Generated schema from Zod: ${schemaName}`)
+}
+
 async function generateZodSchemas(
   logger: InspectorLogger,
   schemaLookup: Map<string, SchemaRef>,
@@ -252,6 +360,7 @@ async function generateZodSchemas(
     ts.ScriptKind.TS
   )
 
+  // Validate all schemas are zod (or unspecified vendor)
   for (const [schemaName, ref] of schemaLookup.entries()) {
     if (ref.vendor && ref.vendor !== 'zod') {
       throw new Error(
@@ -260,55 +369,96 @@ async function generateZodSchemas(
           `Please use Zod or contribute support for ${ref.vendor}.`
       )
     }
+  }
 
-    try {
-      const module = await tsImport(ref.sourceFile, import.meta.url)
-      const zodSchema = module[ref.variableName]
+  // Collect unique source files and batch-import them in parallel
+  const uniqueSourceFiles = [
+    ...new Set([...schemaLookup.values()].map((ref) => ref.sourceFile)),
+  ]
+  console.log(
+    `[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`
+  )
+
+  const importStart = performance.now()
+  const importedModules = await batchImportWithRegister(
+    logger,
+    uniqueSourceFiles
+  )
+  console.log(
+    `[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`
+  )
+
+  const processStart = performance.now()
+  // Track schemas that need per-file tsImport fallback
+  const fallbackSchemas: [string, SchemaRef][] = []
+
+  for (const [schemaName, ref] of schemaLookup.entries()) {
+    const mod = importedModules?.get(ref.sourceFile)
+    if (mod) {
+      const zodSchema = mod[ref.variableName]
       if (!zodSchema) {
         logger.warn(
-          `Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`
+          `Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(mod).join(', ')}`
         )
         continue
       }
+      try {
+        processZodSchema(
+          schemaName,
+          zodSchema,
+          schemas,
+          typesMap,
+          auxiliaryTypeStore,
+          printer,
+          fakeSourceFile,
+          logger
+        )
+      } catch (e) {
+        logger.warn(
+          `Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`
+        )
+      }
+    } else {
+      fallbackSchemas.push([schemaName, ref])
+    }
+  }
 
-      const schema = z.toJSONSchema(zodSchema, {
-        unrepresentable: 'any',
-        override: ({ zodSchema, jsonSchema }) => {
-          if ((zodSchema as any)._zod?.def?.type === 'date') {
-            ;(jsonSchema as any).type = 'string'
-            ;(jsonSchema as any).format = 'date-time'
-          }
-        },
-      }) as any
-
-      if (schema.required && schema.properties) {
-        schema.required = schema.required.filter((fieldName: string) => {
-          const prop = schema.properties[fieldName]
-          return prop && prop.default === undefined
-        })
-        if (schema.required.length === 0) {
-          delete schema.required
+  // Fallback: use tsImport for any schemas that batch import couldn't handle
+  if (fallbackSchemas.length > 0) {
+    logger.debug(
+      `Falling back to tsImport for ${fallbackSchemas.length} schema(s)`
+    )
+    for (const [schemaName, ref] of fallbackSchemas) {
+      try {
+        const module = await tsImport(ref.sourceFile, import.meta.url)
+        const zodSchema = module[ref.variableName]
+        if (!zodSchema) {
+          logger.warn(
+            `Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`
+          )
+          continue
         }
+        processZodSchema(
+          schemaName,
+          zodSchema,
+          schemas,
+          typesMap,
+          auxiliaryTypeStore,
+          printer,
+          fakeSourceFile,
+          logger
+        )
+      } catch (e) {
+        logger.warn(
+          `Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`
+        )
       }
-
-      schemas[schemaName] = schema
-      const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore })
-
-      const typeText = printer.printNode(
-        ts.EmitHint.Unspecified,
-        tsType,
-        fakeSourceFile
-      )
-
-      typesMap.addCustomType(schemaName, typeText, [])
-      logger.debug(`• Generated schema from Zod: ${schemaName}`)
-    } catch (e) {
-      logger.warn(
-        `Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`
-      )
     }
   }
 
+  console.log(
+    `[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`
+  )
   return schemas
 }
 
@@ -347,7 +497,7 @@ export async function generateAllSchemas(
     state.http.meta,
     config.schemasFromTypes,
     config.schema?.additionalProperties,
-    state.schemaLookup
+    zodSchemas
   )
 
   cachedCustomTypesContent = customTypesContent

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

@@ -45,6 +45,7 @@ export interface SerializableInspectorState {
     ]
   >
   wireServicesMeta: Array<[string, string[]]>
+  addonRequiredParentServices: string[]
   configFactories: Array<
     [
       string,
@@ -303,6 +304,7 @@ export function serializeInspectorState(
     ),
     wireServicesFactories: Array.from(state.wireServicesFactories.entries()),
     wireServicesMeta: Array.from(state.wireServicesMeta.entries()),
+    addonRequiredParentServices: state.addonRequiredParentServices,
     configFactories: Array.from(state.configFactories.entries()),
     filesAndMethods: state.filesAndMethods,
     filesAndMethodsErrors: Array.from(
@@ -474,6 +476,7 @@ export function deserializeInspectorState(
     singletonServicesFactories: new Map(data.singletonServicesFactories),
     wireServicesFactories: new Map(data.wireServicesFactories),
     wireServicesMeta: new Map(data.wireServicesMeta),
+    addonRequiredParentServices: data.addonRequiredParentServices || [],
     configFactories: new Map(data.configFactories),
     filesAndMethods: data.filesAndMethods,
     filesAndMethodsErrors: new Map(

package/src/visit.ts

@@ -72,7 +72,8 @@ export const visitSetup = (
     node,
     checker,
     state.singletonServicesFactories,
-    'CreateSingletonServices'
+    'CreateSingletonServices',
+    state
   )
 
   addFileWithFactory(