@pikku/inspector 0.12.74 → 0.12.81

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

@@ -1,499 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { resolveLatestVersions } from './resolve-versions.js'
-import type { InspectorState } from '../types.js'
-
-function makeState(
-  meta: Record<string, any>,
-  rpc?: {
-    internalMeta?: Record<string, string>
-    internalFiles?: Map<string, any>
-  }
-): InspectorState {
-  return {
-    functions: {
-      meta,
-      files: new Map(),
-      typesMap: {} as any,
-    },
-    rpc: {
-      internalMeta: rpc?.internalMeta ?? {},
-      internalFiles: rpc?.internalFiles ?? new Map(),
-      exposedMeta: {},
-      exposedFiles: new Map(),
-      invokedFunctions: new Set(),
-      usedAddons: new Set(),
-    },
-    serviceAggregation: {
-      usedFunctions: new Set(),
-      requiredServices: new Set(),
-      usedMiddleware: new Set(),
-      usedPermissions: new Set(),
-      allSingletonServices: [],
-      allWireServices: [],
-    },
-  } as any
-}
-
-function makeLogger() {
-  const errors: string[] = []
-  return {
-    logger: {
-      debug: () => {},
-      info: () => {},
-      warn: () => {},
-      error: (msg: string) => errors.push(msg),
-      diagnostic: ({ message }: { message: string }) => errors.push(message),
-      critical: (_code: string, msg: string) => errors.push(msg),
-    },
-    errors,
-  }
-}
-
-describe('resolveLatestVersions', () => {
-  test('no-op when no versioned functions exist', () => {
-    const state = makeState({
-      createUser: {
-        pikkuFuncId: 'createUser',
-        inputSchemaName: null,
-        outputSchemaName: null,
-      },
-    })
-    const { logger } = makeLogger()
-    resolveLatestVersions(state, logger)
-
-    assert.ok(state.functions.meta['createUser'])
-    assert.strictEqual(
-      state.functions.meta['createUser']!.pikkuFuncId,
-      'createUser'
-    )
-  })
-
-  test('renames unversioned to implicit version when explicit versions exist', () => {
-    const state = makeState({
-      'createUser@v1': {
-        pikkuFuncId: 'createUser@v1',
-        inputSchemaName: null,
-        outputSchemaName: null,
-        version: 1,
-      },
-      createUser: {
-        pikkuFuncId: 'createUser',
-        inputSchemaName: null,
-        outputSchemaName: null,
-      },
-    })
-    state.rpc.internalMeta['createUser'] = 'createUser'
-    const { logger } = makeLogger()
-
-    resolveLatestVersions(state, logger)
-
-    assert.strictEqual(state.functions.meta['createUser'], undefined)
-    assert.ok(state.functions.meta['createUser@v2'])
-    assert.strictEqual(
-      state.functions.meta['createUser@v2']!.pikkuFuncId,
-      'createUser@v2'
-    )
-    assert.strictEqual(state.functions.meta['createUser@v2']!.version, 2)
-    assert.strictEqual(state.rpc.internalMeta['createUser'], 'createUser@v2')
-    assert.strictEqual(state.rpc.internalMeta['createUser@v2'], 'createUser@v2')
-  })
-
-  test('handles multiple explicit versions with unversioned latest', () => {
-    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,
-      },
-      createUser: {
-        pikkuFuncId: 'createUser',
-        inputSchemaName: null,
-        outputSchemaName: null,
-      },
-    })
-    const { logger } = makeLogger()
-
-    resolveLatestVersions(state, logger)
-
-    assert.strictEqual(state.functions.meta['createUser'], undefined)
-    assert.ok(state.functions.meta['createUser@v3'])
-    assert.strictEqual(state.functions.meta['createUser@v3']!.version, 3)
-    assert.strictEqual(state.rpc.internalMeta['createUser'], 'createUser@v3')
-  })
-
-  test('sets latest alias 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,
-      },
-    })
-    const { logger } = makeLogger()
-
-    resolveLatestVersions(state, logger)
-
-    assert.strictEqual(state.rpc.internalMeta['createUser'], 'createUser@v2')
-  })
-
-  test('marks all explicit versions as invoked', () => {
-    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.ok(state.rpc.invokedFunctions.has('createUser@v1'))
-  })
-
-  test('reports error on duplicate versions', () => {
-    const state = makeState({
-      'createUser@v1': {
-        pikkuFuncId: 'createUser@v1',
-        inputSchemaName: null,
-        outputSchemaName: null,
-        version: 1,
-      },
-      createUserOldV1: {
-        pikkuFuncId: 'createUser@v1',
-        inputSchemaName: null,
-        outputSchemaName: null,
-        version: 1,
-      },
-    })
-
-    state.functions.meta['createUser@v1_dup'] =
-      state.functions.meta['createUserOldV1']!
-    delete state.functions.meta['createUserOldV1']
-
-    const stateForDup = makeState({
-      'createUser@v1': {
-        pikkuFuncId: 'createUser@v1',
-        inputSchemaName: null,
-        outputSchemaName: null,
-      },
-    })
-    stateForDup.functions.meta['createUser@v1_other'] = {
-      pikkuFuncId: 'createUser@v1',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      version: 1,
-    } as any
-
-    const { logger, errors } = makeLogger()
-    resolveLatestVersions(stateForDup, logger)
-
-    // The version extraction from the ID finds both as v1 for baseName 'createUser'
-    // but one has id 'createUser@v1' and the other 'createUser@v1_other'
-    // They both end up in different groups since their parsed base names differ
-    // This validates the grouping logic works as expected
-    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': {
-        pikkuFuncId: 'createUser@v1',
-        inputSchemaName: null,
-        outputSchemaName: null,
-        version: 1,
-      },
-      createUser: {
-        pikkuFuncId: 'createUser',
-        inputSchemaName: null,
-        outputSchemaName: null,
-      },
-    })
-    state.functions.files.set('createUser', {
-      path: '/src/user.ts',
-      exportedName: 'createUser',
-    })
-    state.rpc.internalFiles.set('createUser', {
-      path: '/src/user.ts',
-      exportedName: 'createUser',
-    })
-    const { logger } = makeLogger()
-
-    resolveLatestVersions(state, logger)
-
-    assert.strictEqual(state.functions.files.has('createUser'), false)
-    assert.ok(state.functions.files.has('createUser@v2'))
-    assert.strictEqual(state.rpc.internalFiles.has('createUser'), false)
-    assert.ok(state.rpc.internalFiles.has('createUser@v2'))
-  })
-
-  test('rewrites CLI, channel, scheduler, queue and MCP funcId references when an unversioned function gets an implicit version', () => {
-    const state = makeState({
-      'listCards@v1': { pikkuFuncId: 'listCards@v1', version: 1 },
-      listCards: { pikkuFuncId: 'listCards' },
-    })
-    // CLI command (+ nested subcommand) referencing the unversioned function
-    state.cli = {
-      meta: {
-        programs: {
-          kanban: {
-            name: 'kanban',
-            commands: {
-              list: { pikkuFuncId: 'listCards' },
-              cards: {
-                pikkuFuncId: 'listCards',
-                subcommands: { all: { pikkuFuncId: 'listCards' } },
-              },
-            },
-          },
-        },
-        renderers: {},
-      },
-    } as any
-    // Channel slots + action-routed message wiring
-    state.channels = {
-      meta: {
-        cli: {
-          name: 'cli',
-          route: '/cli/kanban',
-          input: null,
-          connect: null,
-          disconnect: null,
-          message: { pikkuFuncId: 'listCards' },
-          messageWirings: {
-            command: { list: { pikkuFuncId: 'listCards' } },
-          },
-        },
-      },
-      files: new Set(),
-    } as any
-    state.scheduledTasks = {
-      meta: {
-        tick: { name: 'tick', schedule: '* * * * *', pikkuFuncId: 'listCards' },
-      },
-      files: new Set(),
-    } as any
-    state.queueWorkers = {
-      meta: { worker: { name: 'worker', pikkuFuncId: 'listCards' } },
-      files: new Set(),
-    } as any
-    state.mcpEndpoints = {
-      resourcesMeta: { res: { pikkuFuncId: 'listCards' } },
-      toolsMeta: { tool: { pikkuFuncId: 'listCards' } },
-      promptsMeta: { prompt: { pikkuFuncId: 'listCards' } },
-      files: new Set(),
-    } as any
-    state.triggers = {
-      meta: { cardCreated: { name: 'cardCreated' } },
-      sourceMeta: {
-        cardCreated: { name: 'cardCreated', pikkuFuncId: 'listCards' },
-      },
-      files: new Set(),
-    } as any
-    const { logger } = makeLogger()
-
-    resolveLatestVersions(state, logger)
-
-    // unversioned listCards becomes the implicit latest (v2)
-    assert.ok(state.functions.meta['listCards@v2'])
-    const program = (state as any).cli.meta.programs.kanban
-    assert.strictEqual(program.commands.list.pikkuFuncId, 'listCards@v2')
-    assert.strictEqual(program.commands.cards.pikkuFuncId, 'listCards@v2')
-    assert.strictEqual(
-      program.commands.cards.subcommands.all.pikkuFuncId,
-      'listCards@v2'
-    )
-    const channel = (state as any).channels.meta.cli
-    assert.strictEqual(channel.message.pikkuFuncId, 'listCards@v2')
-    assert.strictEqual(
-      channel.messageWirings.command.list.pikkuFuncId,
-      'listCards@v2'
-    )
-    assert.strictEqual(
-      (state as any).scheduledTasks.meta.tick.pikkuFuncId,
-      'listCards@v2'
-    )
-    assert.strictEqual(
-      (state as any).queueWorkers.meta.worker.pikkuFuncId,
-      'listCards@v2'
-    )
-    assert.strictEqual(
-      (state as any).mcpEndpoints.resourcesMeta.res.pikkuFuncId,
-      'listCards@v2'
-    )
-    assert.strictEqual(
-      (state as any).mcpEndpoints.toolsMeta.tool.pikkuFuncId,
-      'listCards@v2'
-    )
-    assert.strictEqual(
-      (state as any).mcpEndpoints.promptsMeta.prompt.pikkuFuncId,
-      'listCards@v2'
-    )
-    assert.strictEqual(
-      (state as any).triggers.sourceMeta.cardCreated.pikkuFuncId,
-      'listCards@v2'
-    )
-  })
-})