@pikku/inspector 0.12.75 → 0.12.82

package/src/utils/load-addon-scopes.test.ts

@@ -1,138 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, test, beforeEach, afterEach } from 'node:test'
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { loadAddonFunctionsMeta } from './load-addon-functions-meta.js'
-
-const PACKAGE = '@test/addon'
-
-let rootDir: string
-let warnings: string[]
-
-const logger = {
-  debug: () => {},
-  info: () => {},
-  warn: (msg: string) => warnings.push(msg),
-  error: () => {},
-} as any
-
-/**
- * Lays out an installed addon the way the host resolves one: a real package in
- * node_modules whose built `.pikku` carries its generated metadata.
- */
-const installAddon = (scopesMeta?: unknown) => {
-  const pkgDir = join(rootDir, 'node_modules', '@test', 'addon')
-  const pikkuDir = join(pkgDir, '.pikku')
-
-  mkdirSync(join(pikkuDir, 'function'), { recursive: true })
-  writeFileSync(
-    join(pkgDir, 'package.json'),
-    JSON.stringify({ name: PACKAGE, version: '1.0.0' }),
-    'utf8'
-  )
-  writeFileSync(
-    join(pikkuDir, 'function', 'pikku-functions-meta.gen.json'),
-    JSON.stringify({ someFunc: { pikkuFuncId: 'someFunc' } }),
-    'utf8'
-  )
-
-  if (scopesMeta !== undefined) {
-    mkdirSync(join(pikkuDir, 'scopes'), { recursive: true })
-    writeFileSync(
-      join(pikkuDir, 'scopes', 'pikku-scopes-meta.gen.json'),
-      JSON.stringify(scopesMeta),
-      'utf8'
-    )
-  }
-}
-
-const makeState = (definitions: any[] = []) =>
-  ({
-    rootDir,
-    addonFunctions: {},
-    addonServerlessIncompatible: new Map(),
-    addonRequiredParentServices: [],
-    mcpEndpoints: { toolsMeta: {} },
-    exportedContracts: { addonHttp: {}, addonCli: {}, addonChannel: {} },
-    secrets: { definitions: [] },
-    variables: { definitions: [] },
-    scopes: { definitions, files: new Set() },
-    schemas: {},
-    rpc: {
-      wireAddonDeclarations: new Map([['test', { package: PACKAGE }]]),
-    },
-  }) as any
-
-beforeEach(() => {
-  rootDir = mkdtempSync(join(tmpdir(), 'pikku-addon-scopes-'))
-  warnings = []
-  writeFileSync(
-    join(rootDir, 'package.json'),
-    JSON.stringify({ name: 'host' }),
-    'utf8'
-  )
-})
-
-afterEach(() => {
-  rmSync(rootDir, { recursive: true, force: true })
-})
-
-describe('loadAddonFunctionsMeta — addon scopes', () => {
-  // Without this, an addon's own scopes never reach the host's ScopeId union or
-  // its declared set, so the pikku_scopes FK would reject granting one.
-  test("merges an addon's declared scopes into the host state", async () => {
-    installAddon({
-      pikku: {
-        name: 'pikku',
-        displayName: 'Pikku',
-        scopes: { scopes: { scopes: { manage: {} } } },
-      },
-    })
-    const state = makeState()
-
-    await loadAddonFunctionsMeta(logger, state)
-
-    assert.deepEqual(
-      state.scopes.definitions.map((d: any) => d.name),
-      ['pikku']
-    )
-    assert.deepEqual(state.scopes.definitions[0].scopes, {
-      scopes: { scopes: { manage: {} } },
-    })
-  })
-
-  test("keeps the host's own scopes alongside the addon's", async () => {
-    installAddon({ pikku: { name: 'pikku' } })
-    const state = makeState([{ name: 'admin' }])
-
-    await loadAddonFunctionsMeta(logger, state)
-
-    assert.deepEqual(state.scopes.definitions.map((d: any) => d.name).sort(), [
-      'admin',
-      'pikku',
-    ])
-  })
-
-  // A host that already declares the name owns it — mirrors how addon secrets
-  // and variables resolve the same collision.
-  test('does not let an addon redeclare a scope the host already owns', async () => {
-    installAddon({ admin: { name: 'admin', description: 'from the addon' } })
-    const state = makeState([{ name: 'admin', description: 'from the host' }])
-
-    await loadAddonFunctionsMeta(logger, state)
-
-    assert.equal(state.scopes.definitions.length, 1)
-    assert.equal(state.scopes.definitions[0].description, 'from the host')
-  })
-
-  test('is a no-op for an addon that declares no scopes', async () => {
-    installAddon()
-    const state = makeState()
-
-    await loadAddonFunctionsMeta(logger, state)
-
-    assert.deepEqual(state.scopes.definitions, [])
-    assert.deepEqual(warnings, [])
-  })
-})

package/src/utils/middleware.test.ts

@@ -1,204 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { resolveAgentMiddleware } from './middleware.js'
-import { getInitialInspectorState } from '../inspector.js'
-import * as ts from 'typescript'
-
-function createSourceFile(code: string): ts.SourceFile {
-  return ts.createSourceFile('test.ts', code, ts.ScriptTarget.ESNext, true)
-}
-
-function getObjectLiteral(
-  sourceFile: ts.SourceFile
-): ts.ObjectLiteralExpression {
-  let result: ts.ObjectLiteralExpression | undefined
-  ts.forEachChild(sourceFile, function visit(node) {
-    if (ts.isObjectLiteralExpression(node) && !result) {
-      result = node
-    }
-    ts.forEachChild(node, visit)
-  })
-  if (!result) throw new Error('No object literal found')
-  return result
-}
-
-function createMockChecker(): ts.TypeChecker {
-  return {} as any
-}
-
-describe('resolveAgentMiddleware', () => {
-  test('should return undefined when no agentMiddleware property exists', () => {
-    const state = getInitialInspectorState('/test')
-    const src = createSourceFile('const x = { name: "test" }')
-    const obj = getObjectLiteral(src)
-    const checker = createMockChecker()
-
-    const result = resolveAgentMiddleware(state, obj, checker)
-
-    assert.strictEqual(result, undefined)
-  })
-
-  test('should return undefined when agentMiddleware array is empty', () => {
-    const state = getInitialInspectorState('/test')
-    const src = createSourceFile('const x = { agentMiddleware: [] }')
-    const obj = getObjectLiteral(src)
-    const checker = createMockChecker()
-
-    const result = resolveAgentMiddleware(state, obj, checker)
-
-    assert.strictEqual(result, undefined)
-  })
-
-  test('should resolve agentMiddleware identifiers as wire metadata', () => {
-    const state = getInitialInspectorState('/test')
-    state.agentMiddleware.definitions['myAIMW'] = {
-      services: { optimized: true, services: ['logger'] },
-      sourceFile: '/test/middleware.ts',
-      position: 0,
-      exportedName: 'myAIMW',
-    }
-
-    const code = 'const x = { agentMiddleware: [myAIMW] }'
-    const program = ts.createProgram({
-      rootNames: ['test.ts'],
-      options: { target: ts.ScriptTarget.ESNext },
-      host: {
-        ...ts.createCompilerHost({}),
-        getSourceFile: (name) => {
-          if (name === 'test.ts')
-            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
-          return undefined
-        },
-        fileExists: (name) => name === 'test.ts',
-        readFile: (name) => (name === 'test.ts' ? code : undefined),
-      },
-    })
-    const checker = program.getTypeChecker()
-    const sourceFile = program.getSourceFile('test.ts')!
-    const obj = getObjectLiteral(sourceFile)
-
-    const result = resolveAgentMiddleware(state, obj, checker)
-
-    assert.ok(result)
-    assert.strictEqual(result.length, 1)
-    assert.deepStrictEqual(result[0], {
-      type: 'wire',
-      name: 'myAIMW',
-      inline: false,
-    })
-  })
-
-  test('should resolve multiple agentMiddleware entries', () => {
-    const state = getInitialInspectorState('/test')
-    state.agentMiddleware.definitions['firstMW'] = {
-      services: { optimized: true, services: ['logger'] },
-      sourceFile: '/test/middleware.ts',
-      position: 0,
-      exportedName: 'firstMW',
-    }
-    state.agentMiddleware.definitions['secondMW'] = {
-      services: { optimized: true, services: [] },
-      sourceFile: '/test/middleware.ts',
-      position: 100,
-      exportedName: 'secondMW',
-    }
-
-    const code = 'const x = { agentMiddleware: [firstMW, secondMW] }'
-    const program = ts.createProgram({
-      rootNames: ['test.ts'],
-      options: { target: ts.ScriptTarget.ESNext },
-      host: {
-        ...ts.createCompilerHost({}),
-        getSourceFile: (name) => {
-          if (name === 'test.ts')
-            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
-          return undefined
-        },
-        fileExists: (name) => name === 'test.ts',
-        readFile: (name) => (name === 'test.ts' ? code : undefined),
-      },
-    })
-    const checker = program.getTypeChecker()
-    const sourceFile = program.getSourceFile('test.ts')!
-    const obj = getObjectLiteral(sourceFile)
-
-    const result = resolveAgentMiddleware(state, obj, checker)
-
-    assert.ok(result)
-    assert.strictEqual(result.length, 2)
-    assert.strictEqual(result[0].type, 'wire')
-    assert.strictEqual((result[0] as any).name, 'firstMW')
-    assert.strictEqual(result[1].type, 'wire')
-    assert.strictEqual((result[1] as any).name, 'secondMW')
-  })
-
-  test('should mark inline agentMiddleware (null exportedName)', () => {
-    const state = getInitialInspectorState('/test')
-    state.agentMiddleware.definitions['inlineMW'] = {
-      services: { optimized: true, services: [] },
-      sourceFile: '/test/middleware.ts',
-      position: 0,
-      exportedName: null,
-    }
-
-    const code = 'const x = { agentMiddleware: [inlineMW] }'
-    const program = ts.createProgram({
-      rootNames: ['test.ts'],
-      options: { target: ts.ScriptTarget.ESNext },
-      host: {
-        ...ts.createCompilerHost({}),
-        getSourceFile: (name) => {
-          if (name === 'test.ts')
-            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
-          return undefined
-        },
-        fileExists: (name) => name === 'test.ts',
-        readFile: (name) => (name === 'test.ts' ? code : undefined),
-      },
-    })
-    const checker = program.getTypeChecker()
-    const sourceFile = program.getSourceFile('test.ts')!
-    const obj = getObjectLiteral(sourceFile)
-
-    const result = resolveAgentMiddleware(state, obj, checker)
-
-    assert.ok(result)
-    assert.strictEqual(result.length, 1)
-    assert.deepStrictEqual(result[0], {
-      type: 'wire',
-      name: 'inlineMW',
-      inline: true,
-    })
-  })
-
-  test('should handle agentMiddleware referencing unknown definitions', () => {
-    const state = getInitialInspectorState('/test')
-
-    const code = 'const x = { agentMiddleware: [unknownMW] }'
-    const program = ts.createProgram({
-      rootNames: ['test.ts'],
-      options: { target: ts.ScriptTarget.ESNext },
-      host: {
-        ...ts.createCompilerHost({}),
-        getSourceFile: (name) => {
-          if (name === 'test.ts')
-            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
-          return undefined
-        },
-        fileExists: (name) => name === 'test.ts',
-        readFile: (name) => (name === 'test.ts' ? code : undefined),
-      },
-    })
-    const checker = program.getTypeChecker()
-    const sourceFile = program.getSourceFile('test.ts')!
-    const obj = getObjectLiteral(sourceFile)
-
-    const result = resolveAgentMiddleware(state, obj, checker)
-
-    assert.ok(result)
-    assert.strictEqual(result.length, 1)
-    assert.strictEqual(result[0].type, 'wire')
-    assert.strictEqual((result[0] as any).name, 'unknownMW')
-    assert.strictEqual((result[0] as any).inline, false)
-  })
-})

package/src/utils/middleware.ts

@@ -1,303 +0,0 @@
-import * as ts from 'typescript'
-import type { MiddlewareMetadata } from '@pikku/core/middleware'
-import { extractFunctionName } from './extract-function-name.js'
-import type { InspectorState } from '../types.js'
-
-export interface MiddlewareRef {
-  definitionId: string
-  isFactoryCall: boolean
-}
-
-export function extractMiddlewareRefs(
-  arrayNode: ts.Expression,
-  checker: ts.TypeChecker,
-  rootDir: string
-): MiddlewareRef[] {
-  if (!ts.isArrayLiteralExpression(arrayNode)) {
-    return []
-  }
-
-  const refs: MiddlewareRef[] = []
-  for (const element of arrayNode.elements) {
-    if (ts.isIdentifier(element)) {
-      const { pikkuFuncId } = extractFunctionName(element, checker, rootDir)
-      refs.push({
-        definitionId: pikkuFuncId.startsWith('__temp_')
-          ? element.text
-          : pikkuFuncId,
-        isFactoryCall: false,
-      })
-    } else if (ts.isCallExpression(element)) {
-      const { pikkuFuncId } = extractFunctionName(
-        element.expression,
-        checker,
-        rootDir
-      )
-      refs.push({
-        definitionId:
-          pikkuFuncId.startsWith('__temp_') &&
-          ts.isIdentifier(element.expression)
-            ? element.expression.text
-            : pikkuFuncId,
-        isFactoryCall: true,
-      })
-    }
-  }
-  return refs
-}
-
-export function extractMiddlewarePikkuNames(
-  arrayNode: ts.Expression,
-  checker: ts.TypeChecker,
-  rootDir: string
-): string[] {
-  return extractMiddlewareRefs(arrayNode, checker, rootDir).map(
-    (r) => r.definitionId
-  )
-}
-
-export function getMiddlewareNode(
-  obj: ts.ObjectLiteralExpression
-): ts.Expression | undefined {
-  const middlewareProp = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === 'middleware'
-  ) as ts.PropertyAssignment | undefined
-
-  return middlewareProp?.initializer
-}
-
-export function routeMatchesPattern(route: string, pattern: string): boolean {
-  if (route === pattern) return true
-
-  const regexPattern = pattern
-    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*/g, '.*')
-
-  const regex = new RegExp(`^${regexPattern}$`)
-  return regex.test(route)
-}
-
-export function resolveHTTPMiddleware(
-  state: InspectorState,
-  route: string,
-  tags: string[] | undefined,
-  explicitMiddlewareNode: ts.Expression | undefined,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] | undefined {
-  const resolved: MiddlewareMetadata[] = []
-
-  for (const [pattern, _groupMeta] of state.http.routeMiddleware.entries()) {
-    if (routeMatchesPattern(route, pattern)) {
-      resolved.push({
-        type: 'http',
-        route: pattern,
-      })
-    }
-  }
-
-  if (tags && tags.length > 0) {
-    for (const tag of tags) {
-      if (state.middleware.tagMiddleware.has(tag)) {
-        resolved.push({
-          type: 'tag',
-          tag,
-        })
-      }
-    }
-  }
-
-  if (explicitMiddlewareNode) {
-    const middlewareNames = extractMiddlewarePikkuNames(
-      explicitMiddlewareNode,
-      checker,
-      state.rootDir
-    )
-    for (const name of middlewareNames) {
-      const def = state.middleware.definitions[name]
-      resolved.push({
-        type: 'wire',
-        name,
-        inline: def?.exportedName === null,
-      })
-    }
-  }
-
-  return resolved.length > 0 ? resolved : undefined
-}
-
-function resolveTagAndExplicitMiddleware(
-  state: InspectorState,
-  tags: string[] | undefined,
-  explicitMiddlewareNode: ts.Expression | undefined,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] {
-  const resolved: MiddlewareMetadata[] = []
-
-  if (tags && tags.length > 0) {
-    for (const tag of tags) {
-      if (state.middleware.tagMiddleware.has(tag)) {
-        resolved.push({
-          type: 'tag',
-          tag,
-        })
-      }
-    }
-  }
-
-  if (explicitMiddlewareNode) {
-    const middlewareNames = extractMiddlewarePikkuNames(
-      explicitMiddlewareNode,
-      checker,
-      state.rootDir
-    )
-    for (const name of middlewareNames) {
-      const def = state.middleware.definitions[name]
-      resolved.push({
-        type: 'wire',
-        name,
-        inline: def?.exportedName === null,
-      })
-    }
-  }
-
-  return resolved
-}
-
-function resolveFunctionMiddlewareInternal(
-  state: InspectorState,
-  tags: string[] | undefined,
-  explicitMiddlewareNode: ts.Expression | undefined,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] | undefined {
-  const resolved = resolveTagAndExplicitMiddleware(
-    state,
-    tags,
-    explicitMiddlewareNode,
-    checker
-  )
-
-  return resolved.length > 0 ? resolved : undefined
-}
-
-export function resolveMiddleware(
-  state: InspectorState,
-  obj: ts.ObjectLiteralExpression,
-  tags: string[] | undefined,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] | undefined {
-  const explicitMiddlewareNode = getMiddlewareNode(obj)
-  return resolveFunctionMiddlewareInternal(
-    state,
-    tags,
-    explicitMiddlewareNode,
-    checker
-  )
-}
-
-export function resolveHTTPMiddlewareFromObject(
-  state: InspectorState,
-  route: string,
-  obj: ts.ObjectLiteralExpression,
-  tags: string[] | undefined,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] | undefined {
-  const explicitMiddlewareNode = getMiddlewareNode(obj)
-  return resolveHTTPMiddleware(
-    state,
-    route,
-    tags,
-    explicitMiddlewareNode,
-    checker
-  )
-}
-
-function getAgentMiddlewareNode(
-  obj: ts.ObjectLiteralExpression
-): ts.Expression | undefined {
-  const prop = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === 'agentMiddleware'
-  ) as ts.PropertyAssignment | undefined
-  return prop?.initializer
-}
-
-export function resolveAgentMiddleware(
-  state: InspectorState,
-  obj: ts.ObjectLiteralExpression,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] | undefined {
-  const explicitNode = getAgentMiddlewareNode(obj)
-  if (!explicitNode) return undefined
-
-  const names = extractMiddlewarePikkuNames(
-    explicitNode,
-    checker,
-    state.rootDir
-  )
-  const resolved: MiddlewareMetadata[] = names.map((name) => {
-    const def = state.agentMiddleware.definitions[name]
-    return {
-      type: 'wire' as const,
-      name,
-      inline: def?.exportedName === null,
-    }
-  })
-
-  return resolved.length > 0 ? resolved : undefined
-}
-
-function getChannelMiddlewareNode(
-  obj: ts.ObjectLiteralExpression
-): ts.Expression | undefined {
-  const prop = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === 'channelMiddleware'
-  ) as ts.PropertyAssignment | undefined
-  return prop?.initializer
-}
-
-export function resolveChannelMiddleware(
-  state: InspectorState,
-  obj: ts.ObjectLiteralExpression,
-  tags: string[] | undefined,
-  checker: ts.TypeChecker
-): MiddlewareMetadata[] | undefined {
-  const resolved: MiddlewareMetadata[] = []
-
-  if (tags && tags.length > 0) {
-    for (const tag of tags) {
-      if (state.channelMiddleware.tagMiddleware.has(tag)) {
-        resolved.push({
-          type: 'tag',
-          tag,
-        })
-      }
-    }
-  }
-
-  const explicitNode = getChannelMiddlewareNode(obj)
-  if (explicitNode) {
-    const names = extractMiddlewarePikkuNames(
-      explicitNode,
-      checker,
-      state.rootDir
-    )
-    for (const name of names) {
-      const def = state.channelMiddleware.definitions[name]
-      resolved.push({
-        type: 'wire',
-        name,
-        inline: def?.exportedName === null,
-      })
-    }
-  }
-
-  return resolved.length > 0 ? resolved : undefined
-}

package/src/utils/nested-project-filter.test.ts

@@ -1,53 +0,0 @@
-import { test } from 'node:test'
-import * as assert from 'node:assert'
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { createNestedProjectFilter } from './nested-project-filter.js'
-
-test('createNestedProjectFilter', async (t) => {
-  const root = mkdtempSync(join(tmpdir(), 'pikku-nested-'))
-  t.after(() => rmSync(root, { recursive: true, force: true }))
-
-  writeFileSync(join(root, 'pikku.config.json'), '{}')
-  mkdirSync(join(root, 'packages/functions/src'), { recursive: true })
-  mkdirSync(join(root, 'packages/addon/src'), { recursive: true })
-  mkdirSync(join(root, 'packages/addon/types'), { recursive: true })
-  writeFileSync(join(root, 'packages/addon/pikku.config.json'), '{}')
-
-  const isNested = createNestedProjectFilter(root)
-
-  await t.test('keeps project source files', () => {
-    assert.strictEqual(
-      isNested(join(root, 'packages/functions/src/auth.ts')),
-      false
-    )
-  })
-
-  await t.test('keeps files directly under rootDir', () => {
-    assert.strictEqual(isNested(join(root, 'services.ts')), false)
-  })
-
-  await t.test('excludes files inside a nested pikku project', () => {
-    assert.strictEqual(
-      isNested(join(root, 'packages/addon/types/application-types.d.ts')),
-      true
-    )
-    assert.strictEqual(
-      isNested(join(root, 'packages/addon/src/index.ts')),
-      true
-    )
-  })
-
-  await t.test('keeps files outside rootDir untouched', () => {
-    assert.strictEqual(isNested('/somewhere/else/file.ts'), false)
-  })
-
-  await t.test('rootDir itself is not treated as nested', () => {
-    const addonScoped = createNestedProjectFilter(join(root, 'packages/addon'))
-    assert.strictEqual(
-      addonScoped(join(root, 'packages/addon/src/index.ts')),
-      false
-    )
-  })
-})