@pikku/inspector 0.12.75 → 0.12.82

package/src/utils/resolve-versions.ts

@@ -1,228 +0,0 @@
-import { parseVersionedId, formatVersionedId } from '@pikku/core/utils'
-import type { CLICommandMeta } from '@pikku/core/cli'
-import type { InspectorState, InspectorLogger } from '../types.js'
-import { ErrorCode } from '../error-codes.js'
-
-export function resolveLatestVersions(
-  state: InspectorState,
-  logger: InspectorLogger
-): void {
-  const functionsMeta = state.functions.meta
-
-  const groups = new Map<
-    string,
-    {
-      explicit: { id: string; version: number }[]
-      unversioned: string | null
-    }
-  >()
-
-  for (const [id, meta] of Object.entries(functionsMeta)) {
-    const parsed = parseVersionedId(id)
-    const baseName = parsed.version !== null ? parsed.baseName : id
-    let group = groups.get(baseName)
-    if (!group) {
-      group = { explicit: [], unversioned: null }
-      groups.set(baseName, group)
-    }
-    if (parsed.version !== null) {
-      group.explicit.push({ id, version: parsed.version })
-    } else if (meta.version !== undefined) {
-      group.explicit.push({ id, version: meta.version })
-    } else {
-      group.unversioned = id
-    }
-  }
-
-  for (const [baseName, group] of groups) {
-    if (group.explicit.length === 0) {
-      continue
-    }
-
-    const seen = new Map<number, string>()
-    for (const entry of group.explicit) {
-      const existing = seen.get(entry.version)
-      if (existing) {
-        logger.critical(
-          ErrorCode.DUPLICATE_FUNCTION_VERSION,
-          `Duplicate version ${entry.version} for function '${baseName}': '${existing}' and '${entry.id}'.`
-        )
-      }
-      seen.set(entry.version, entry.id)
-    }
-
-    const maxVersion = Math.max(...group.explicit.map((e) => e.version))
-
-    if (group.unversioned) {
-      const implicitVersion = maxVersion + 1
-      const oldId = group.unversioned
-      const newId = formatVersionedId(baseName, implicitVersion)
-
-      const meta = functionsMeta[oldId]!
-      meta.pikkuFuncId = newId
-      meta.version = implicitVersion
-      delete functionsMeta[oldId]
-      functionsMeta[newId] = meta
-
-      const fileEntry = state.functions.files.get(oldId)
-      if (fileEntry) {
-        state.functions.files.delete(oldId)
-        state.functions.files.set(newId, fileEntry)
-      }
-
-      const rpcFileEntry = state.rpc.internalFiles.get(oldId)
-      if (rpcFileEntry) {
-        state.rpc.internalFiles.delete(oldId)
-        state.rpc.internalFiles.set(newId, rpcFileEntry)
-      }
-
-      if (state.rpc.invokedFunctions.has(oldId)) {
-        state.rpc.invokedFunctions.delete(oldId)
-        state.rpc.invokedFunctions.add(newId)
-      }
-
-      if (state.serviceAggregation.usedFunctions.has(oldId)) {
-        state.serviceAggregation.usedFunctions.delete(oldId)
-        state.serviceAggregation.usedFunctions.add(newId)
-      }
-
-      state.rpc.internalMeta[baseName] = newId
-      state.rpc.internalMeta[newId] = newId
-
-      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
-      )
-      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 {
-  // HTTP routes
-  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
-        }
-      }
-    }
-  }
-
-  // Channels: connect/disconnect/message slots + action-routed message wirings
-  if (state.channels) {
-    for (const channel of Object.values(state.channels.meta)) {
-      for (const slot of [
-        channel.connect,
-        channel.disconnect,
-        channel.message,
-      ]) {
-        if (slot && slot.pikkuFuncId === oldId) {
-          slot.pikkuFuncId = newId
-        }
-      }
-      for (const routes of Object.values(channel.messageWirings)) {
-        for (const message of Object.values(routes)) {
-          if (message.pikkuFuncId === oldId) {
-            message.pikkuFuncId = newId
-          }
-        }
-      }
-    }
-  }
-
-  // CLI programs: commands and nested subcommands. This also covers
-  // CLI-over-channel generation, which reads command funcIds from this meta.
-  if (state.cli) {
-    const updateCommands = (commands: Record<string, CLICommandMeta>): void => {
-      for (const command of Object.values(commands)) {
-        if (command.pikkuFuncId === oldId) {
-          command.pikkuFuncId = newId
-        }
-        if (command.subcommands) {
-          updateCommands(command.subcommands)
-        }
-      }
-    }
-    for (const program of Object.values(state.cli.meta.programs)) {
-      updateCommands(program.commands)
-    }
-  }
-
-  // Scheduled tasks
-  if (state.scheduledTasks) {
-    for (const task of Object.values(state.scheduledTasks.meta)) {
-      if (task.pikkuFuncId === oldId) {
-        task.pikkuFuncId = newId
-      }
-    }
-  }
-
-  // Queue workers
-  if (state.queueWorkers) {
-    for (const worker of Object.values(state.queueWorkers.meta)) {
-      if (worker.pikkuFuncId === oldId) {
-        worker.pikkuFuncId = newId
-      }
-    }
-  }
-
-  // Trigger sources (TriggerSourceMeta carries the handler's pikkuFuncId).
-  // Gateways/workflows/agents reference functions by bare rpc name and are
-  // resolved at runtime via state.rpc.internalMeta, so they need no rewrite here.
-  if (state.triggers) {
-    for (const source of Object.values(state.triggers.sourceMeta)) {
-      if (source.pikkuFuncId === oldId) {
-        source.pikkuFuncId = newId
-      }
-    }
-  }
-
-  // MCP resources, tools, and prompts
-  if (state.mcpEndpoints) {
-    for (const collection of [
-      state.mcpEndpoints.resourcesMeta,
-      state.mcpEndpoints.toolsMeta,
-      state.mcpEndpoints.promptsMeta,
-    ]) {
-      for (const endpoint of Object.values(collection)) {
-        if (endpoint.pikkuFuncId === oldId) {
-          endpoint.pikkuFuncId = newId
-        }
-      }
-    }
-  }
-}

package/src/utils/schema-cache.test.ts

@@ -1,124 +0,0 @@
-import { test, describe } from 'node:test'
-import { strict as assert } from 'node:assert'
-import {
-  mkdtempSync,
-  rmSync,
-  statSync,
-  utimesSync,
-  writeFileSync,
-} from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import {
-  readDiskTSSchemas,
-  writeDiskTSSchemas,
-  type SchemaDep,
-} from './schema-generator.js'
-import type { InspectorLogger } from '../types.js'
-
-const silentLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-} as unknown as InspectorLogger
-
-const KEY = 'test-key'
-const SCHEMAS = { Thing: { type: 'object' } }
-
-/** A cache directory and one source file the cached schemas claim to derive from. */
-function makeCache(sourceContent: string): {
-  cacheDir: string
-  source: string
-  deps: SchemaDep[]
-  cleanup: () => void
-} {
-  const dir = mkdtempSync(join(tmpdir(), 'pikku-schema-cache-'))
-  const source = join(dir, 'thing.ts')
-  writeFileSync(source, sourceContent)
-  const stat = statSync(source)
-  return {
-    cacheDir: dir,
-    source,
-    deps: [{ path: source, mtimeMs: stat.mtimeMs, size: stat.size }],
-    cleanup: () => rmSync(dir, { recursive: true, force: true }),
-  }
-}
-
-describe('TS schema disk cache', () => {
-  test('serves the cached schemas while their sources are untouched', () => {
-    const { cacheDir, deps, cleanup } = makeCache('export interface Thing {}')
-    try {
-      writeDiskTSSchemas(silentLogger, cacheDir, KEY, SCHEMAS, deps)
-      const hit = readDiskTSSchemas(silentLogger, cacheDir, KEY)
-      assert.deepEqual(hit?.schemas, SCHEMAS)
-    } finally {
-      cleanup()
-    }
-  })
-
-  test('discards the cache when a type it was built from changes', () => {
-    const { cacheDir, source, deps, cleanup } = makeCache(
-      'export interface Thing {}'
-    )
-    try {
-      writeDiskTSSchemas(silentLogger, cacheDir, KEY, SCHEMAS, deps)
-      // The shape changes but the name does not, so the cache key — which hashes
-      // only the synthesized custom-types source — is identical. This is the case
-      // that used to serve a stale schema, and it survived `rm -rf .pikku`
-      // because the cache lives under node_modules/.cache.
-      writeFileSync(source, 'export interface Thing { added: string }')
-      assert.equal(readDiskTSSchemas(silentLogger, cacheDir, KEY), null)
-    } finally {
-      cleanup()
-    }
-  })
-
-  test('discards the cache when a source is rewritten to the same size', () => {
-    const { cacheDir, source, deps, cleanup } = makeCache('export type A = 1')
-    try {
-      writeDiskTSSchemas(silentLogger, cacheDir, KEY, SCHEMAS, deps)
-      // Same byte count, different type: size alone would call this unchanged, so
-      // the mtime half of the fingerprint is what has to catch it.
-      writeFileSync(source, 'export type A = 2')
-      utimesSync(source, new Date(), new Date(Date.now() + 5000))
-      assert.equal(readDiskTSSchemas(silentLogger, cacheDir, KEY), null)
-    } finally {
-      cleanup()
-    }
-  })
-
-  test('discards the cache when a source it was built from is deleted', () => {
-    const { cacheDir, source, deps, cleanup } = makeCache('export type A = 1')
-    try {
-      writeDiskTSSchemas(silentLogger, cacheDir, KEY, SCHEMAS, deps)
-      rmSync(source)
-      assert.equal(readDiskTSSchemas(silentLogger, cacheDir, KEY), null)
-    } finally {
-      cleanup()
-    }
-  })
-
-  test('discards a cache written before deps were tracked', () => {
-    const { cacheDir, cleanup } = makeCache('export type A = 1')
-    try {
-      writeFileSync(
-        join(cacheDir, 'ts-schemas.json'),
-        JSON.stringify({ key: KEY, schemas: SCHEMAS })
-      )
-      assert.equal(readDiskTSSchemas(silentLogger, cacheDir, KEY), null)
-    } finally {
-      cleanup()
-    }
-  })
-
-  test('still misses on a different key', () => {
-    const { cacheDir, deps, cleanup } = makeCache('export type A = 1')
-    try {
-      writeDiskTSSchemas(silentLogger, cacheDir, KEY, SCHEMAS, deps)
-      assert.equal(readDiskTSSchemas(silentLogger, cacheDir, 'other'), null)
-    } finally {
-      cleanup()
-    }
-  })
-})

package/src/utils/schema-generator.test.ts

@@ -1,272 +0,0 @@
-import { test, describe, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { fileURLToPath } from 'url'
-
-import { getInitialInspectorState } from '../inspector.js'
-import { generateAllSchemas, schemaRuntimeFile } from './schema-generator.js'
-
-const debugLines: string[] = []
-const logger = {
-  debug(message: string) {
-    debugLines.push(message)
-  },
-  info() {},
-  warn() {},
-  error() {},
-} as any
-
-const UNRELATED_FILE_COUNT = 300
-
-let projectDir: string
-
-before(() => {
-  projectDir = mkdtempSync(join(tmpdir(), 'pikku-schema-gen-'))
-  mkdirSync(join(projectDir, 'src'))
-  writeFileSync(
-    join(projectDir, 'tsconfig.json'),
-    JSON.stringify({
-      compilerOptions: {
-        target: 'ESNext',
-        module: 'NodeNext',
-        moduleResolution: 'NodeNext',
-        strict: true,
-        skipLibCheck: true,
-      },
-      include: ['src/**/*.ts'],
-    })
-  )
-  writeFileSync(
-    join(projectDir, 'src', 'types.ts'),
-    'export type Thing = { id: string; count: number }\n'
-  )
-  // Files the tsconfig picks up but no generated custom type references. They
-  // stand in for the bulk of a real project, which the schema program has no
-  // reason to load.
-  for (let i = 0; i < UNRELATED_FILE_COUNT; i += 1) {
-    writeFileSync(
-      join(projectDir, 'src', `unrelated-${i}.ts`),
-      `export type Unrelated${i} = { a: string; b: number; c: boolean }\n`
-    )
-  }
-})
-
-after(() => {
-  rmSync(projectDir, { recursive: true, force: true })
-})
-
-describe('generateAllSchemas', () => {
-  // NOTE: this must be the first test in the file. The module-level caches are
-  // per-process, so only the first call actually builds a program — a later call
-  // reuses it and would measure a few MB no matter what.
-  //
-  // The schema generator builds a second ts.Program over the whole tsconfig —
-  // on a real tree that is ~2.5k files and ~600MB, and it used to be pinned at
-  // module scope for the life of the process. Combined with the main inspector
-  // program it pushed peak heap past 2GB and OOM'd `pikku all` (#982).
-  //
-  // Only the program is released; cachedTSSchemas (the small result cache that
-  // powers the same-process fast path) is deliberately kept.
-  test('does not retain the schema ts.Program after returning', async (t) => {
-    if (typeof global.gc !== 'function') {
-      t.skip('requires --expose-gc')
-      return
-    }
-
-    const state = getInitialInspectorState(projectDir) as any
-    // A distinct type keeps this off the cachedTSSchemas fast path, so the
-    // program is genuinely rebuilt (and therefore genuinely retainable) here.
-    state.functions.typesMap.addCustomType(
-      'RetentionProbeInput',
-      '{ probe: string; n: number }',
-      []
-    )
-
-    global.gc!()
-    const before = process.memoryUsage().heapUsed
-
-    await generateAllSchemas(
-      logger,
-      { tsconfig: join(projectDir, 'tsconfig.json') },
-      state
-    )
-
-    global.gc!()
-    const retainedMB = (process.memoryUsage().heapUsed - before) / 1024 / 1024
-
-    // A retained program (with its SourceFiles and TypeChecker) measures tens of
-    // MB even for this one-file fixture; the schemas themselves are a few KB.
-    assert.ok(
-      retainedMB < 10,
-      `expected the schema program to be released, but ${retainedMB.toFixed(1)}MB is still retained after GC`
-    )
-  })
-
-  // The virtual file explicitly imports every type it needs, so it is a complete
-  // root on its own. Rooting the program at the whole tsconfig instead made it
-  // load the entire project (2572 files on a real tree vs 870), for no gain in
-  // what could be resolved (#982).
-  test('scopes the schema program to the virtual file import closure', async () => {
-    debugLines.length = 0
-
-    const state = getInitialInspectorState(projectDir) as any
-    state.functions.typesMap.addCustomType(
-      'ScopingProbeInput',
-      '{ scope: string }',
-      []
-    )
-
-    await generateAllSchemas(
-      logger,
-      { tsconfig: join(projectDir, 'tsconfig.json') },
-      state
-    )
-
-    const line = debugLines.find((l) => l.includes('Created schema program'))
-    assert.ok(
-      line,
-      `expected a "Created schema program" debug line, got: ${debugLines.join(' | ')}`
-    )
-
-    const fileCount = Number(line!.match(/(\d+) files/)?.[1])
-    assert.ok(
-      Number.isFinite(fileCount),
-      `could not parse a file count out of: ${line}`
-    )
-    // The virtual file plus types.ts plus the default lib. Rooting at the whole
-    // tsconfig would pull in all UNRELATED_FILE_COUNT files on top of that.
-    assert.ok(
-      fileCount < UNRELATED_FILE_COUNT,
-      `expected the schema program to skip the ${UNRELATED_FILE_COUNT} unreferenced files, but it loaded ${fileCount}`
-    )
-  })
-
-  test('produces a schema for a custom type', async () => {
-    const state = getInitialInspectorState(projectDir) as any
-    state.functions.typesMap.addCustomType(
-      'ThingInput',
-      '{ id: string; count: number }',
-      []
-    )
-
-    const schemas = await generateAllSchemas(
-      logger,
-      { tsconfig: join(projectDir, 'tsconfig.json') },
-      state
-    )
-
-    assert.ok(
-      Object.keys(schemas).length > 0,
-      'expected at least one generated schema'
-    )
-  })
-})
-
-/**
- * A schema imported from a built workspace package resolves to that package's
- * declaration file, and a `.d.ts` has no runtime exports at all — every one of
- * them is a type. Importing it to read the zod object yields an empty module and
- * every schema in it is reported missing, so the emitted JS beside it is what has
- * to be imported.
- */
-describe('schemaRuntimeFile', () => {
-  test('a source file the developer wrote is imported as it is', () => {
-    const written = join(projectDir, 'src', 'types.ts')
-    assert.equal(schemaRuntimeFile(written), written)
-  })
-
-  test('a declaration file resolves to the JS emitted beside it', () => {
-    writeFileSync(
-      join(projectDir, 'src', 'reindex.d.ts'),
-      'export declare const a: number\n'
-    )
-    writeFileSync(join(projectDir, 'src', 'reindex.js'), 'export const a = 1\n')
-    assert.equal(
-      schemaRuntimeFile(join(projectDir, 'src', 'reindex.d.ts')),
-      join(projectDir, 'src', 'reindex.js')
-    )
-  })
-
-  test('.d.mts resolves to the ESM file beside it', () => {
-    writeFileSync(
-      join(projectDir, 'src', 'esm.d.mts'),
-      'export declare const a: number\n'
-    )
-    writeFileSync(join(projectDir, 'src', 'esm.mjs'), 'export const a = 1\n')
-    assert.equal(
-      schemaRuntimeFile(join(projectDir, 'src', 'esm.d.mts')),
-      join(projectDir, 'src', 'esm.mjs')
-    )
-  })
-
-  test('.d.cts resolves to the CommonJS file beside it', () => {
-    // Its own test rather than a second assertion above: the two extensions are
-    // separate branches, and one covering both is one that passes while half of
-    // it is broken.
-    writeFileSync(
-      join(projectDir, 'src', 'commonjs.d.cts'),
-      'export declare const a: number\n'
-    )
-    writeFileSync(join(projectDir, 'src', 'commonjs.cjs'), 'exports.a = 1\n')
-    assert.equal(
-      schemaRuntimeFile(join(projectDir, 'src', 'commonjs.d.cts')),
-      join(projectDir, 'src', 'commonjs.cjs')
-    )
-  })
-
-  test('a declaration file with no emitted JS keeps its own path', () => {
-    // So the "could not find exported schema" error still names a file the
-    // developer can open, rather than one that was never written.
-    const orphan = join(projectDir, 'src', 'types-only.d.ts')
-    writeFileSync(orphan, 'export declare const a: number\n')
-    assert.equal(schemaRuntimeFile(orphan), orphan)
-  })
-})
-
-describe('a Zod schema that cannot be a wire contract', () => {
-  test('names .transform() and its own error code, not a downstream one', async () => {
-    // A transform used to surface as PKU724 — the *bad `#pikku/*` import* error
-    // — because the schema failed to convert, its generated leaf never got
-    // written, and the type that leaf feeds resolved to an error type. The
-    // message sent you to an import block that was fine.
-    // Inside the package, so the fixture's `import 'zod'` resolves the same
-    // way a project's would; a tmpdir has no node_modules above it.
-    const dir = mkdtempSync(
-      join(fileURLToPath(new URL('../../', import.meta.url)), '.zod-transform-')
-    )
-    try {
-      const file = join(dir, 'schema.ts')
-      writeFileSync(
-        file,
-        `import * as z from 'zod'\n` +
-          `export const CreateAssessment = z.object({ patientId: z.string(), when: z.string().transform((s) => new Date(s)) })\n`
-      )
-      const state = getInitialInspectorState(dir) as any
-      state.schemaLookup.set('CreateAssessmentInput', {
-        variableName: 'CreateAssessment',
-        sourceFile: file,
-        vendor: 'zod',
-      })
-
-      const errors: string[] = []
-      await assert.rejects(() =>
-        generateAllSchemas(
-          { ...logger, error: (m: string) => errors.push(m) },
-          { tsconfig: join(projectDir, 'tsconfig.json') },
-          state
-        )
-      )
-
-      const reported = errors.join('\n')
-      assert.match(reported, /PKU491/)
-      assert.match(reported, /CreateAssessmentInput/)
-      assert.match(reported, /\.transform\(\)/)
-      assert.match(reported, /\.when/)
-      assert.doesNotMatch(reported, /PKU724/)
-    } finally {
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-})