@roundtable-bb/sdk 0.1.2 → 0.1.4

package/codegen/generate.ts

@@ -1,298 +0,0 @@
-/**
- * Reads openapi.json and generates packages/sdk/src/generated/client.ts.
- * Run from workspace root: tsx packages/sdk/codegen/generate.ts
- */
-
-import { readFileSync, writeFileSync, mkdirSync } from 'fs'
-import { join, dirname } from 'path'
-import { fileURLToPath } from 'url'
-import { $ZodRegistry, $ZodType, toJSONSchema } from 'zod/v4/core'
-import * as types from '@roundtable-bb/types'
-import type { ZodTypeAny } from 'zod'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-// ─── Convert Zod schema → OpenAPI 3.0 JSON Schema (same logic as fastify-type-provider-zod) ─
-
-const IDENTITY_KEYWORDS = new Set(['id', '$id', '$schema'])
-
-function sanitize(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(sanitize)
-  if (value === null || typeof value !== 'object') return value
-  const result: Record<string, unknown> = {}
-  for (const [k, child] of Object.entries(value as Record<string, unknown>)) {
-    if (IDENTITY_KEYWORDS.has(k)) continue
-    if (k === 'properties' && child !== null && typeof child === 'object') {
-      result[k] = Object.fromEntries(
-        Object.entries(child as Record<string, unknown>).map(([n, s]) => [n, sanitize(s)]),
-      )
-    } else {
-      result[k] = sanitize(child)
-    }
-  }
-  return result
-}
-
-function zodToOpenApi(schema: ZodTypeAny, io: 'input' | 'output'): Record<string, unknown> {
-  const PLACEHOLDER = '__ID__'
-  const reg = new $ZodRegistry()
-  reg.add(schema as unknown as InstanceType<typeof $ZodType>, { id: PLACEHOLDER })
-  const { schemas } = toJSONSchema(reg, {
-    target: 'openapi-3.0',
-    io,
-    cycles: 'ref',
-    reused: 'inline',
-    unrepresentable: 'any',
-    uri: () => '__URI__',
-  })
-  return sanitize(schemas[PLACEHOLDER]) as Record<string, unknown>
-}
-
-// ─── Build known-schema registry (input = request bodies, output = responses) ─
-
-type SchemaEntry = { typeName: string; input: Record<string, unknown>; output: Record<string, unknown> }
-const registry: SchemaEntry[] = []
-
-for (const [key, value] of Object.entries(types)) {
-  if (!key.endsWith('Schema') || key === 'PaginatedResponseSchema') continue
-  if (typeof value !== 'object' || !value || !('_zod' in value)) continue
-  const typeName = key.replace(/Schema$/, '')
-  try {
-    const input = zodToOpenApi(value as ZodTypeAny, 'input')
-    const output = zodToOpenApi(value as ZodTypeAny, 'output')
-    if (Object.keys(output).length > 0) registry.push({ typeName, input, output })
-  } catch {
-    // skip unconvertible schemas
-  }
-}
-
-// ─── Deep equality ───────────────────────────────────────────────────────────
-
-function deepEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true
-  if (typeof a !== typeof b || typeof a !== 'object') return false
-  if (a === null || b === null) return false
-  const ka = Object.keys(a as object).sort()
-  const kb = Object.keys(b as object).sort()
-  if (ka.length !== kb.length || ka.join('\0') !== kb.join('\0')) return false
-  return ka.every((k) =>
-    deepEqual((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k]),
-  )
-}
-
-// ─── Schema → TypeScript type ─────────────────────────────────────────────────
-
-const usedTypes = new Set<string>()
-
-function primitiveType(schema: Record<string, unknown>): string {
-  if (schema.type === 'string') return 'string'
-  if (schema.type === 'integer' || schema.type === 'number') return 'number'
-  if (schema.type === 'boolean') return 'boolean'
-  if (schema.type === 'null') return 'null'
-  if (schema.anyOf) {
-    const variants = (schema.anyOf as Record<string, unknown>[]).map(primitiveType)
-    return variants.join(' | ')
-  }
-  return 'unknown'
-}
-
-function matchSchema(schema: Record<string, unknown>, io: 'input' | 'output' = 'output'): string | null {
-  // Direct match against known schemas from @roundtable-bb/types
-  for (const { typeName, input, output } of registry) {
-    if (deepEqual(schema, io === 'input' ? input : output)) {
-      usedTypes.add(typeName)
-      return typeName
-    }
-  }
-
-  // Array: { type: 'array', items: X }
-  if (schema.type === 'array' && schema.items && typeof schema.items === 'object') {
-    const itemsSchema = schema.items as Record<string, unknown>
-    const inner = matchSchema(itemsSchema, io) ?? primitiveType(itemsSchema)
-    if (inner !== 'unknown') return `${inner}[]`
-  }
-
-  // Paginated: { type: 'object', properties: { items: { type: 'array', items: X }, nextCursor: ... } }
-  if (schema.type === 'object' && schema.properties && typeof schema.properties === 'object') {
-    const props = schema.properties as Record<string, Record<string, unknown>>
-    const itemsProp = props['items']
-    const nextCursorProp = props['nextCursor']
-    if (
-      itemsProp?.type === 'array' &&
-      typeof itemsProp.items === 'object' &&
-      nextCursorProp !== undefined
-    ) {
-      const inner = matchSchema(itemsProp.items as Record<string, unknown>, io)
-      if (inner) {
-        usedTypes.add('PaginatedResponse')
-        return `PaginatedResponse<${inner}>`
-      }
-    }
-  }
-
-  return null
-}
-
-function resolveType(schema: Record<string, unknown> | undefined, io: 'input' | 'output' = 'output'): string {
-  if (!schema) return 'void'
-  return matchSchema(schema, io) ?? primitiveType(schema)
-}
-
-// ─── Parse OpenAPI spec ───────────────────────────────────────────────────────
-
-type Param = { name: string; tsType: string; required: boolean }
-
-type Operation = {
-  operationId: string
-  method: string
-  path: string
-  pathParams: Param[]
-  queryParams: Param[]
-  bodyType: string | null
-  responseType: string
-  summary: string
-}
-
-const specPath = join(__dirname, '../openapi.json')
-const spec = JSON.parse(readFileSync(specPath, 'utf-8')) as {
-  paths: Record<
-    string,
-    Record<
-      string,
-      {
-        operationId?: string
-        summary?: string
-        parameters?: Array<{
-          name: string
-          in: string
-          required?: boolean
-          schema?: Record<string, unknown>
-        }>
-        requestBody?: {
-          content?: { 'application/json'?: { schema?: Record<string, unknown> } }
-        }
-        responses?: Record<
-          string,
-          { content?: { 'application/json'?: { schema?: Record<string, unknown> } } }
-        >
-      }
-    >
-  >
-}
-
-const operations: Operation[] = []
-
-for (const [rawPath, methods] of Object.entries(spec.paths ?? {})) {
-  for (const [method, op] of Object.entries(methods)) {
-    if (!op.operationId) continue
-
-    const pathParams: Param[] = (op.parameters ?? [])
-      .filter((p) => p.in === 'path')
-      .map((p) => ({ name: p.name, tsType: 'string', required: true }))
-
-    const queryParams: Param[] = (op.parameters ?? [])
-      .filter((p) => p.in === 'query')
-      .map((p) => ({
-        name: p.name,
-        tsType: p.schema ? resolveType(p.schema, 'input') : 'string',
-        required: !!p.required,
-      }))
-
-    const bodySchema = op.requestBody?.content?.['application/json']?.schema
-    const bodyType = bodySchema ? resolveType(bodySchema, 'input') : null
-
-    const [responseCode, responseEntry] =
-      Object.entries(op.responses ?? {}).find(([code]) => code.startsWith('2')) ?? [
-        '200',
-        undefined,
-      ]
-
-    const responseType =
-      responseCode === '204'
-        ? 'void'
-        : resolveType(
-            (
-              responseEntry as {
-                content?: { 'application/json'?: { schema?: Record<string, unknown> } }
-              }
-            )?.content?.['application/json']?.schema,
-          )
-
-    operations.push({
-      operationId: op.operationId,
-      method: method.toUpperCase(),
-      path: rawPath,
-      pathParams,
-      queryParams,
-      bodyType,
-      responseType,
-      summary: op.summary ?? '',
-    })
-  }
-}
-
-// ─── Emit client class ────────────────────────────────────────────────────────
-
-function buildTemplatePath(path: string): string {
-  const converted = path.replace(/\{([^}]+)\}/g, '${params.$1}')
-  return converted.includes('${') ? `\`${converted}\`` : `'${converted}'`
-}
-
-function emitMethod(op: Operation): string {
-  const args: string[] = []
-
-  if (op.pathParams.length > 0) {
-    const shape = op.pathParams.map((p) => `${p.name}: ${p.tsType}`).join('; ')
-    args.push(`params: { ${shape} }`)
-  }
-  if (op.bodyType) args.push(`body: ${op.bodyType}`)
-  if (op.queryParams.length > 0) {
-    const shape = op.queryParams
-      .map((p) => `${p.name}${p.required ? '' : '?'}: ${p.tsType}`)
-      .join('; ')
-    args.push(`query?: { ${shape} }`)
-  }
-
-  const requestArgs: string[] = ['this.opts', `'${op.method}'`, buildTemplatePath(op.path)]
-  const requestOpts: string[] = []
-  if (op.bodyType) requestOpts.push('body')
-  if (op.queryParams.length > 0) requestOpts.push('query')
-  if (requestOpts.length > 0) requestArgs.push(`{ ${requestOpts.join(', ')} }`)
-
-  return [
-    `  /** ${op.summary} */`,
-    `  ${op.operationId}(${args.join(', ')}): Promise<${op.responseType}> {`,
-    `    return request(${requestArgs.join(', ')})`,
-    `  }`,
-  ].join('\n')
-}
-
-const importedTypes = [...usedTypes].sort()
-const importLine =
-  importedTypes.length > 0
-    ? `import type { ${importedTypes.join(', ')} } from '@roundtable-bb/types'`
-    : ''
-
-const methods = operations
-  .sort((a, b) => a.operationId.localeCompare(b.operationId))
-  .map(emitMethod)
-  .join('\n\n')
-
-const output = `\
-// AUTO-GENERATED — do not edit manually.
-// Run \`nx run @roundtable-bb/sdk:codegen\` to regenerate.
-
-${importLine}
-import { request, type RoundtableClientOpts } from '../request.js'
-
-export class RoundtableClient {
-  constructor(private readonly opts: RoundtableClientOpts) {}
-
-${methods}
-}
-`
-
-const outDir = join(__dirname, '../src/generated')
-mkdirSync(outDir, { recursive: true })
-writeFileSync(join(outDir, 'client.ts'), output)
-console.log(`✓ Generated ${operations.length} operations → src/generated/client.ts`)