mppx 0.8.15 → 0.8.18

package/src/cli/validate/discovery.test.ts

@@ -1,435 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import {
-  buildUrl,
-  extractEndpointsFromDiscovery,
-  extractRequestBodyFromDiscovery,
-} from './discovery.js'
-
-describe('buildUrl', () => {
-  describe('path parameters', () => {
-    test('substitutes param with example from parameter', () => {
-      const endpoint = {
-        method: 'GET',
-        path: '/users/{userId}/posts',
-        parameters: [{ name: 'userId', in: 'path' as const, example: 'abc-123' }],
-      }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/users/abc-123/posts')
-    })
-
-    test('substitutes param with example from schema', () => {
-      const endpoint = {
-        method: 'GET',
-        path: '/orders/{orderId}',
-        parameters: [{ name: 'orderId', in: 'path' as const, schema: { example: 'ORD-001' } }],
-      }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/orders/ORD-001')
-    })
-
-    test('substitutes param with default from schema', () => {
-      const endpoint = {
-        method: 'GET',
-        path: '/items/{itemId}',
-        parameters: [{ name: 'itemId', in: 'path' as const, schema: { default: '42' } }],
-      }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/items/42')
-    })
-
-    test('leaves placeholder when no example available', () => {
-      const endpoint = {
-        method: 'GET',
-        path: '/users/{userId}',
-        parameters: [{ name: 'userId', in: 'path' as const, schema: { type: 'string' } }],
-      }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/users/%7BuserId%7D')
-    })
-
-    test('handles multiple path params', () => {
-      const endpoint = {
-        method: 'GET',
-        path: '/orgs/{orgId}/repos/{repoId}',
-        parameters: [
-          { name: 'orgId', in: 'path' as const, example: 'stripe' },
-          { name: 'repoId', in: 'path' as const, example: 'mppx' },
-        ],
-      }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/orgs/stripe/repos/mppx')
-    })
-
-    test('encodes special characters', () => {
-      const endpoint = {
-        method: 'GET',
-        path: '/search/{query}',
-        parameters: [{ name: 'query', in: 'path' as const, example: 'hello world' }],
-      }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/search/hello%20world')
-    })
-
-    test('no parameters field leaves path as-is', () => {
-      const endpoint = { method: 'GET', path: '/simple' }
-      expect(buildUrl('http://localhost', endpoint)).toBe('http://localhost/simple')
-    })
-  })
-
-  describe('subpath base URL', () => {
-    test('preserves base URL subpath', () => {
-      const endpoint = { method: 'POST', path: '/plan' }
-      expect(buildUrl('http://localhost/mpp', endpoint)).toBe('http://localhost/mpp/plan')
-    })
-
-    test('preserves nested subpath', () => {
-      const endpoint = { method: 'GET', path: '/users/123' }
-      expect(buildUrl('http://localhost/api/v1', endpoint)).toBe(
-        'http://localhost/api/v1/users/123',
-      )
-    })
-
-    test('works with trailing slash on base', () => {
-      const endpoint = { method: 'POST', path: '/plan' }
-      expect(buildUrl('http://localhost/mpp/', endpoint)).toBe('http://localhost/mpp/plan')
-    })
-  })
-})
-
-describe('extractEndpointsFromDiscovery', () => {
-  describe('path parameters', () => {
-    test('extracts parameters from OpenAPI doc', () => {
-      const doc = {
-        openapi: '3.1.0',
-        paths: {
-          '/users/{userId}': {
-            parameters: [
-              { name: 'userId', in: 'path', schema: { type: 'string', example: 'u-1' } },
-            ],
-            get: {
-              'x-payment-info': { amount: '100' },
-              responses: { '402': {} },
-            },
-          },
-        },
-      }
-      const endpoints = extractEndpointsFromDiscovery(doc as Record<string, unknown>)
-      expect(endpoints).toHaveLength(1)
-      expect(endpoints[0]!.parameters).toHaveLength(1)
-      expect(endpoints[0]!.parameters![0]!.name).toBe('userId')
-      expect(buildUrl('http://localhost', endpoints[0]!)).toBe('http://localhost/users/u-1')
-    })
-
-    test('operation params override path-level params', () => {
-      const doc = {
-        openapi: '3.1.0',
-        paths: {
-          '/items/{id}': {
-            parameters: [{ name: 'id', in: 'path', example: 'path-level' }],
-            post: {
-              'x-payment-info': { amount: '100' },
-              parameters: [{ name: 'id', in: 'path', example: 'op-level' }],
-            },
-          },
-        },
-      }
-      const endpoints = extractEndpointsFromDiscovery(doc as Record<string, unknown>)
-      expect(buildUrl('http://localhost', endpoints[0]!)).toBe('http://localhost/items/op-level')
-    })
-  })
-
-  describe('endpoint selection', () => {
-    test('prefers x-payment-info endpoints over 402 heuristic', () => {
-      const doc = {
-        paths: {
-          '/paid': { post: { 'x-payment-info': { amount: '100' }, responses: { '402': {} } } },
-          '/maybe': { get: { responses: { '402': {} } } },
-        },
-      }
-      const endpoints = extractEndpointsFromDiscovery(doc as Record<string, unknown>)
-      expect(endpoints).toHaveLength(1)
-      expect(endpoints[0]!.path).toBe('/paid')
-    })
-
-    test('falls back to 402 heuristic when no x-payment-info', () => {
-      const doc = {
-        paths: {
-          '/a': { get: { responses: { '402': {} } } },
-          '/b': { post: { responses: { '402': {} } } },
-        },
-      }
-      const endpoints = extractEndpointsFromDiscovery(doc as Record<string, unknown>)
-      expect(endpoints).toHaveLength(2)
-    })
-
-    test('returns empty for no paths', () => {
-      expect(extractEndpointsFromDiscovery({} as Record<string, unknown>)).toEqual([])
-    })
-
-    test('captures amount from x-payment-info', () => {
-      const doc = {
-        paths: {
-          '/api/generate': {
-            post: { 'x-payment-info': { amount: '50000' }, responses: { '402': {} } },
-          },
-        },
-      }
-      const endpoints = extractEndpointsFromDiscovery(doc as Record<string, unknown>)
-      expect(endpoints[0]!.amount).toBe('50000')
-    })
-  })
-})
-
-describe('extractRequestBodyFromDiscovery', () => {
-  test('returns explicit example from content', () => {
-    const doc = {
-      paths: {
-        '/api/test': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': { example: { prompt: 'hello' } },
-              },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(body).toBe('{"prompt":"hello"}')
-  })
-
-  test('generates body from schema with required fields', () => {
-    const doc = {
-      paths: {
-        '/api/test': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    required: ['query', 'count'],
-                    properties: {
-                      query: { type: 'string', example: 'test query' },
-                      count: { type: 'integer', default: 10 },
-                      optional: { type: 'string' },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(JSON.parse(body!)).toEqual({ query: 'test query', count: 10 })
-  })
-
-  test('uses schema defaults for scalar types', () => {
-    const doc = {
-      paths: {
-        '/api/test': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    required: ['email', 'active'],
-                    properties: {
-                      email: { type: 'string', format: 'email' },
-                      active: { type: 'boolean' },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(JSON.parse(body!)).toEqual({ email: 'test@example.com', active: true })
-  })
-
-  test('returns undefined when no requestBody', () => {
-    const doc = { paths: { '/api/test': { post: {} } } }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(body).toBeUndefined()
-  })
-
-  test('returns undefined when path not found', () => {
-    const doc = { paths: { '/other': { get: {} } } }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(body).toBeUndefined()
-  })
-
-  test('handles enum in schema', () => {
-    const doc = {
-      paths: {
-        '/api/test': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    required: ['model'],
-                    properties: {
-                      model: { type: 'string', enum: ['gpt-4', 'gpt-3.5'] },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(JSON.parse(body!)).toEqual({ model: 'gpt-4' })
-  })
-
-  test('resolves $ref to components/schemas', () => {
-    const doc = {
-      paths: {
-        '/api/orders': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  schema: { $ref: '#/components/schemas/OrderRequest' },
-                },
-              },
-            },
-          },
-        },
-      },
-      components: {
-        schemas: {
-          OrderRequest: {
-            type: 'object',
-            required: ['product', 'quantity'],
-            properties: {
-              product: { type: 'string', example: 'widget' },
-              quantity: { type: 'integer', minimum: 1 },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/orders',
-    })
-    expect(JSON.parse(body!)).toEqual({ product: 'widget', quantity: 1 })
-  })
-
-  test('resolves nested $ref in properties', () => {
-    const doc = {
-      paths: {
-        '/api/orders': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  schema: { $ref: '#/components/schemas/OrderRequest' },
-                },
-              },
-            },
-          },
-        },
-      },
-      components: {
-        schemas: {
-          OrderRequest: {
-            type: 'object',
-            required: ['customer'],
-            properties: {
-              customer: { $ref: '#/components/schemas/Customer' },
-            },
-          },
-          Customer: {
-            type: 'object',
-            required: ['name', 'email'],
-            properties: {
-              name: { type: 'string' },
-              email: { type: 'string', format: 'email' },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/orders',
-    })
-    expect(JSON.parse(body!)).toEqual({ customer: { name: 'test', email: 'test@example.com' } })
-  })
-
-  test('uses first named example from examples map', () => {
-    const doc = {
-      paths: {
-        '/api/test': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  examples: {
-                    basic: { value: { prompt: 'hello', model: 'gpt-4' } },
-                    advanced: { value: { prompt: 'complex', model: 'gpt-4', temp: 0.9 } },
-                  },
-                  schema: { type: 'object' },
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(JSON.parse(body!)).toEqual({ prompt: 'hello', model: 'gpt-4' })
-  })
-
-  test('returns undefined for unresolvable $ref', () => {
-    const doc = {
-      paths: {
-        '/api/test': {
-          post: {
-            requestBody: {
-              content: {
-                'application/json': {
-                  schema: { $ref: '#/components/schemas/DoesNotExist' },
-                },
-              },
-            },
-          },
-        },
-      },
-      components: { schemas: {} },
-    }
-    const body = extractRequestBodyFromDiscovery(doc as Record<string, unknown>, {
-      method: 'POST',
-      path: '/api/test',
-    })
-    expect(body).toBeUndefined()
-  })
-})

package/src/cli/validate/discovery.ts

@@ -1,221 +0,0 @@
-import type { EndpointSpec, PathParameter } from './helpers.js'
-import { fetchWithTimeout, HTTP_METHODS } from './helpers.js'
-
-export async function fetchDiscoveryDoc(
-  baseUrl: string,
-): Promise<{ doc: unknown; raw: string } | { error: string }> {
-  // Trailing slash makes URL treat baseUrl as a directory, so relative resolution appends rather than replaces the last segment.
-  const url = new URL('openapi.json', baseUrl.replace(/\/?$/, '/')).href
-  try {
-    const response = await fetchWithTimeout(url, {})
-    if (!response.ok) return { error: `HTTP ${response.status}` }
-    const raw = await response.text()
-    const doc = JSON.parse(raw)
-    return { doc, raw }
-  } catch (error) {
-    if (error instanceof DOMException && error.name === 'AbortError')
-      return { error: 'Request timed out after 15s' }
-    if (error instanceof SyntaxError) return { error: 'Invalid JSON' }
-    return { error: (error as Error).message }
-  }
-}
-
-// Extracts testable endpoints from an OpenAPI doc. Prefers endpoints with
-// explicit x-payment-info (the server declares them as paid). Falls back to
-// endpoints that list a 402 response (weaker signal, but still worth testing).
-export function extractEndpointsFromDiscovery(doc: Record<string, unknown>): EndpointSpec[] {
-  const withPaymentInfo: EndpointSpec[] = []
-  const with402Response: EndpointSpec[] = []
-  const paths = doc.paths as Record<string, Record<string, unknown>> | undefined
-  if (!paths) return []
-  for (const [pathKey, pathItem] of Object.entries(paths)) {
-    const pathLevelParams = extractPathParameters(pathItem.parameters)
-
-    for (const [method, operation] of Object.entries(pathItem)) {
-      if (!HTTP_METHODS.has(method)) continue
-      if (!operation || typeof operation !== 'object' || Array.isArray(operation)) continue
-      const op = operation as Record<string, unknown>
-
-      const opParams = extractPathParameters(op.parameters)
-      const merged = mergeParameters(pathLevelParams, opParams)
-      const params = merged.length > 0 ? merged : undefined
-
-      if (op['x-payment-info']) {
-        const payInfo = op['x-payment-info'] as Record<string, unknown>
-        withPaymentInfo.push({
-          method: method.toUpperCase(),
-          path: pathKey,
-          amount: payInfo.amount as string | undefined,
-          parameters: params,
-        })
-      } else {
-        const responses = op.responses as Record<string, unknown> | undefined
-        if (responses && '402' in responses) {
-          with402Response.push({ method: method.toUpperCase(), path: pathKey, parameters: params })
-        }
-      }
-    }
-  }
-  return withPaymentInfo.length > 0 ? withPaymentInfo : with402Response
-}
-
-export function extractRequestBodyFromDiscovery(
-  doc: Record<string, unknown>,
-  endpoint: EndpointSpec,
-): string | undefined {
-  const paths = doc.paths as Record<string, Record<string, unknown>> | undefined
-  if (!paths) return undefined
-  const pathItem = paths[endpoint.path]
-  if (!pathItem) return undefined
-  const op = pathItem[endpoint.method.toLowerCase()] as Record<string, unknown> | undefined
-  if (!op?.requestBody) return undefined
-
-  const rb = op.requestBody as Record<string, unknown>
-  const content = rb.content as Record<string, unknown> | undefined
-  const jsonContent = content?.['application/json'] as Record<string, unknown> | undefined
-  if (!jsonContent) return undefined
-
-  if (jsonContent.example) return JSON.stringify(jsonContent.example)
-
-  if (jsonContent.examples && typeof jsonContent.examples === 'object') {
-    const first = Object.values(jsonContent.examples as Record<string, unknown>)[0] as
-      | Record<string, unknown>
-      | undefined
-    if (first?.value) return JSON.stringify(first.value)
-  }
-
-  let schema = jsonContent.schema as Record<string, unknown> | undefined
-  const seen = new Set<string>()
-  schema = resolveRef(schema, doc, seen)
-  if (!schema || schema.type !== 'object') return undefined
-
-  const result = generateValueFromSchema(schema, doc, seen)
-  if (result && typeof result === 'object' && Object.keys(result as object).length > 0) {
-    return JSON.stringify(result)
-  }
-  return undefined
-}
-
-export function buildUrl(baseUrl: string, endpoint: EndpointSpec, query?: string[]): string {
-  let path = endpoint.path
-  if (endpoint.parameters) {
-    path = substitutePathParams(path, endpoint.parameters)
-  }
-  // Strip leading slash so URL resolves relative to baseUrl's path, not root.
-  const relativePath = path.startsWith('/') ? path.slice(1) : path
-  let url = new URL(relativePath, baseUrl.replace(/\/?$/, '/')).href
-  if (query) {
-    const u = new URL(url)
-    for (const q of query) {
-      const [key, ...rest] = q.split('=')
-      if (key) u.searchParams.set(key, rest.join('='))
-    }
-    url = u.href
-  }
-  return url
-}
-
-// ── Internal helpers ─────────────────────────────────────────────────────────
-
-function extractPathParameters(raw: unknown): PathParameter[] {
-  if (!Array.isArray(raw)) return []
-  const results: PathParameter[] = []
-  for (const p of raw) {
-    if (!p || typeof p !== 'object') continue
-    const param = p as Record<string, unknown>
-    if (param.in !== 'path' || typeof param.name !== 'string') continue
-    results.push(
-      param.schema && typeof param.schema === 'object'
-        ? {
-            name: param.name,
-            in: 'path' as const,
-            schema: param.schema as NonNullable<PathParameter['schema']>,
-            example: param.example,
-          }
-        : { name: param.name, in: 'path' as const, example: param.example },
-    )
-  }
-  return results
-}
-
-function mergeParameters(base: PathParameter[], override: PathParameter[]): PathParameter[] {
-  const merged = [...base]
-  for (const p of override) {
-    const idx = merged.findIndex((m) => m.name === p.name)
-    if (idx >= 0) merged[idx] = p
-    else merged.push(p)
-  }
-  return merged
-}
-
-function substitutePathParams(path: string, params: PathParameter[]): string {
-  return path.replace(/\{([^}]+)\}/g, (match, name) => {
-    const param = params.find((p) => p.name === name && p.in === 'path')
-    if (!param) return match
-    const value = param.example ?? param.schema?.example ?? param.schema?.default
-    if (value === undefined) return match
-    return encodeURIComponent(String(value))
-  })
-}
-
-// Dereferences a JSON Schema $ref (e.g. "#/components/schemas/Foo") against the root doc.
-function resolveRef(
-  schema: Record<string, unknown> | undefined,
-  doc: Record<string, unknown>,
-  seen?: Set<string>,
-): Record<string, unknown> | undefined {
-  if (!schema || typeof schema.$ref !== 'string') return schema
-  if (seen?.has(schema.$ref)) return undefined
-  const path = schema.$ref.replace(/^#\//, '').split('/')
-  let resolved: unknown = doc
-  for (const segment of path) {
-    if (resolved && typeof resolved === 'object') resolved = (resolved as any)[segment]
-    else return undefined
-  }
-  return resolved as Record<string, unknown> | undefined
-}
-
-// Generates a plausible value for a JSON Schema node (required fields only for objects).
-function generateValueFromSchema(
-  schema: Record<string, unknown>,
-  doc: Record<string, unknown>,
-  seen?: Set<string>,
-): unknown {
-  const resolved = resolveRef(schema, doc, seen) ?? schema
-  if (resolved.const !== undefined) return resolved.const
-  if (resolved.example !== undefined) return resolved.example
-  if (resolved.default !== undefined) return resolved.default
-
-  switch (resolved.type) {
-    case 'string': {
-      if (resolved.enum && Array.isArray(resolved.enum)) return resolved.enum[0]
-      if (resolved.format === 'email') return 'test@example.com'
-      if (resolved.format === 'uuid') return '00000000-0000-0000-0000-000000000000'
-      if (resolved.format === 'uri' || resolved.format === 'url') return 'https://example.com'
-      if (resolved.format === 'date') return '2026-01-01'
-      if (resolved.pattern === '^\\d{5}(?:-\\d{4})?$') return '10001'
-      if (resolved.pattern === '^[A-Z]{2}$') return 'US'
-      return 'test'
-    }
-    case 'number':
-    case 'integer':
-      return (resolved.minimum as number) ?? 1
-    case 'boolean':
-      return true
-    case 'array':
-      return []
-    case 'object': {
-      const properties = resolved.properties as Record<string, Record<string, unknown>> | undefined
-      if (!properties) return {}
-      const required = (resolved.required as string[]) || []
-      const obj: Record<string, unknown> = {}
-      for (const key of required) {
-        const prop = properties[key]
-        if (prop) obj[key] = generateValueFromSchema(prop, doc, seen)
-      }
-      return obj
-    }
-    default:
-      return null
-  }
-}