@roundtable-bb/sdk 0.1.0

package/codegen/bundle.mjs

@@ -0,0 +1,26 @@
+/**
+ * Bundles the SDK as an IIFE for legacy frontends (window.Roundtable).
+ * Run: node packages/sdk/codegen/bundle.mjs
+ */
+
+import { build } from 'esbuild'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const root = join(__dirname, '..')
+
+await build({
+  entryPoints: [join(root, 'src/index.ts')],
+  bundle: true,
+  platform: 'browser',
+  format: 'iife',
+  globalName: 'Roundtable',
+  outfile: join(root, 'dist/roundtable.iife.js'),
+  minify: true,
+  sourcemap: true,
+  target: ['es2017'],
+  external: [],
+})
+
+console.log('✓ IIFE bundle written to dist/roundtable.iife.js')

package/codegen/extract-spec.ts

@@ -0,0 +1,27 @@
+/**
+ * Boots the Fastify app (without real connections) and writes openapi.json.
+ * Run from workspace root: tsx packages/sdk/codegen/extract-spec.ts
+ */
+
+// Dummy env vars — prevent real connection attempts
+process.env['DATABASE_URL'] ??= 'postgresql://x:x@localhost:5432/x'
+process.env['VALKEY_URL'] ??= 'redis://localhost:6379'
+process.env['JWT_SECRET'] ??= 'dummy-for-spec-extraction'
+process.env['BETTER_AUTH_SECRET'] ??= 'dummy-for-spec-extraction'
+process.env['AUTH_DOMAIN'] ??= 'auth.localhost'
+process.env['PLATFORM_OWNER_IDS'] ??= ''
+
+import { writeFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { buildApp } from '../../../apps/api/src/app.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+const app = await buildApp()
+await app.ready()
+const spec = app.swagger()
+const outPath = join(__dirname, '../openapi.json')
+writeFileSync(outPath, JSON.stringify(spec, null, 2))
+console.log(`✓ OpenAPI spec written to ${outPath}`)
+await app.close()

package/codegen/generate.ts

@@ -0,0 +1,298 @@
+/**
+ * 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`)