fix(cli): make tables rows create and tables columns run usable

Both were dead on arrival, for opposite reasons.

`createTableRows` takes `z.union([batch, single])`. A union has no flat field
list, so the generator emitted no body slot — and slot absence reads the same
as "this operation has no body", so the command offered nothing and sent
nothing. The generator's own comment claimed the runtime fell back to taking
the body as JSON; nothing did. Unions are now marked, the fields every branch
shares are still emitted (both require `workspaceId`, which comes from the
profile), and `--body <json|@file>` carries the rest, merged over them so the
caller still wins on any key it sets. Dropping that merge was my first attempt
and it failed on the missing workspace.

`runTableColumn` takes `limit: { type, max }`. The pager claimed the *name*
`limit` regardless of type, so it became `--limit <n>` with a default of 100
and sent a number the route rejected on every call, whether or not the flag was
passed. The special case now applies only where `limit` is numeric; elsewhere
it is an ordinary field and gets the JSON flag its type calls for.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0148a65fkPhP4N8tgGPYtRTU

Author: TheodoreSpeaks

packages/sim-cli/src/generated/v2-api.ts

@@ -4233,6 +4233,10 @@ export const V2_OPERATIONS = {
     pathParams: ['tableId'] as const,
     responseMode: 'json',
     summary: 'Create Rows',
+    body: {
+      workspaceId: { kind: 'string', required: true },
+    },
+    opaqueBody: true,
   },
   createTableView: {
     method: 'POST',

packages/sim-cli/src/runtime/build.test.ts

@@ -328,3 +328,66 @@ describe('boolean flags', () => {
     )
   })
 })
+
+describe('bodies and fields the generator cannot flatten', () => {
+  it('sends a union body whole, with the profile workspace merged in', async () => {
+    // `createTableRows` is `z.union([batch, single])`, so there is no field list
+    // to build flags from. The command exposed nothing at all and sent no body,
+    // and every call failed with "Request body must be valid JSON".
+    const [path, options] = await run([
+      'tables',
+      'rows',
+      'create',
+      'tbl_1',
+      '--body',
+      '{"rows":[{"city":"Paris"}]}',
+    ])
+
+    expect(path).toBe('/api/v2/tables/tbl_1/rows')
+    // Both branches require `workspaceId`, and it comes from the profile.
+    expect(options.body).toEqual({ workspaceId: 'ws_local', rows: [{ city: 'Paris' }] })
+  })
+
+  it('lets the caller override a shared field', async () => {
+    const [, options] = await run([
+      'tables',
+      'rows',
+      'create',
+      'tbl_1',
+      '--body',
+      '{"workspaceId":"ws_other","rows":[]}',
+    ])
+    expect(options.body).toMatchObject({ workspaceId: 'ws_other' })
+  })
+
+  it('refuses a union body that is not an object', async () => {
+    await expect(run(['tables', 'rows', 'create', 'tbl_1', '--body', '[1,2]'])).rejects.toThrow(
+      /--body must be a JSON object/
+    )
+  })
+
+  it('leaves a non-numeric `limit` alone', async () => {
+    // `runTableColumn` takes `limit: { type, max }`. The pager claimed the name
+    // regardless of type, turning it into `--limit <n>` that defaulted to 100,
+    // so every call failed with "expected object, received number".
+    const [, omitted] = await run(['tables', 'columns', 'run', 'tbl_1', '--group-ids', '["g1"]'])
+    expect(omitted.body).not.toHaveProperty('limit')
+
+    const [, given] = await run([
+      'tables',
+      'columns',
+      'run',
+      'tbl_1',
+      '--group-ids',
+      '["g1"]',
+      '--limit',
+      '{"type":"rows","max":5}',
+    ])
+    expect(given.body).toMatchObject({ limit: { type: 'rows', max: 5 } })
+  })
+
+  it('still gives paginated lists their numeric --limit', async () => {
+    const [, options] = await run(['files', 'list', '--limit', '7'])
+    expect(options.query).toMatchObject({ limit: 7 })
+  })
+})

packages/sim-cli/src/runtime/build.ts

@@ -153,6 +153,11 @@ function unwrapResource(data: unknown): unknown {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : data
 }
 
+/** Whether the operation's body is one the generator could not describe field by field. */
+function opaqueBody(spec: object): boolean {
+  return (spec as { opaqueBody?: boolean }).opaqueBody === true
+}
+
 /** The operation's one-line help, taken from the OpenAPI summary at generation time. */
 function summaryFor(operation: V2OperationName): string | undefined {
   return (V2_OPERATIONS[operation] as { summary?: string }).summary
@@ -195,7 +200,11 @@ function addFieldOption(
   const name = flagNameFor(operation, field)
   const short = flag.short ? `-${flag.short}, ` : ''
 
-  if (field === 'limit') {
+  // The pager owns `--limit`, but only where `limit` means a page size. The
+  // name is not reserved: `runTableColumn` takes `limit: { type, max }`, and
+  // claiming it here turned that into a numeric flag that defaulted to 100 and
+  // made every invocation fail with "expected object, received number".
+  if (field === 'limit' && (descriptor.kind === 'number' || descriptor.kind === 'integer')) {
     command.option(
       `--limit <n>`,
       'Maximum items to return (0 for everything)',
@@ -286,6 +295,17 @@ function buildLeaf(operation: V2OperationName, spec: CommandSpec, leafName: stri
     }
   }
 
+  // A body the generator could not break into fields is offered whole. The
+  // union behind `tables rows create` (one row, or a batch) has no field list
+  // to build flags from, and without this the command sent no body at all and
+  // the server rejected the request as malformed JSON.
+  if (opaqueBody(operationSpec)) {
+    command.requiredOption(
+      '--body <json|@file>',
+      'Request body as JSON (or @path / @- to read a file or stdin)'
+    )
+  }
+
   if (spec.confirm) {
     command.option('-y, --yes', 'Skip the confirmation')
   }

packages/sim-cli/src/runtime/request.ts

@@ -213,6 +213,7 @@ export function buildRequest(
     pathParams: readonly string[]
     query?: Record<string, FieldSpec>
     body?: Record<string, FieldSpec>
+    opaqueBody?: boolean
   }
 
   let path = spec.path
@@ -256,6 +257,20 @@ export function buildRequest(
     }
   }
 
+  // A union body comes in whole through `--body`, merged over the fields the
+  // branches share. Replacing outright dropped the profile's `workspaceId`,
+  // which both branches require, so every insert came back as invalid input.
+  // The caller's JSON still wins on any key it sets.
+  if (spec.opaqueBody) {
+    const raw = flags.body
+    if (typeof raw !== 'string') throw new SimApiError('--body is required', 0)
+    const parsed = coerce(raw, { kind: 'object' }, { json: true }, 'body')
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new SimApiError('--body must be a JSON object', 0)
+    }
+    return { path, query, body: { ...body, ...(parsed as Record<string, unknown>) } }
+  }
+
   return {
     path,
     query,

scripts/generate-v2-cli-api.ts

@@ -341,16 +341,46 @@ function fieldKind(schema: JsonSchema): FieldKind {
  * Emitted as data rather than baked into types because the CLI has to *iterate*
  * these at startup to construct commands — a type alone cannot be walked.
  */
+/**
+ * Whether the slot is a union, whose branches the CLI cannot turn into flags.
+ *
+ * Distinct from "the map came out empty": the shared fields of a union are
+ * emitted as a map, so emptiness alone no longer identifies one, and the
+ * runtime still has to know the rest of the body must come in as JSON.
+ */
+function isUnionSlot(schema: z.ZodType): boolean {
+  const json = z.toJSONSchema(schema, { io: 'input', unrepresentable: 'any' }) as JsonSchema
+  return Object.keys(json.properties ?? {}).length === 0 && Boolean(json.anyOf ?? json.oneOf)
+}
+
 function renderSlotMap(schema: z.ZodType | undefined, indent: string): string | null {
   if (!schema) return null
 
   const json = z.toJSONSchema(schema, { io: 'input', unrepresentable: 'any' }) as JsonSchema
-  const properties: Record<string, JsonSchema> = json.properties ?? {}
-  const required = new Set<string>(json.required ?? [])
+  let properties: Record<string, JsonSchema> = json.properties ?? {}
+  let required = new Set<string>(json.required ?? [])
+
+  // A union has no properties of its own, but the fields every branch agrees on
+  // are still known and still have to be sent — `workspaceId` is required by
+  // both branches of the row-insert body and comes from the profile, so
+  // dropping it left `tables rows create` rejected as invalid input.
+  if (Object.keys(properties).length === 0) {
+    const branches = (json.anyOf ?? json.oneOf) as JsonSchema[] | undefined
+    if (branches?.length) {
+      const shared = branches.reduce<string[]>(
+        (keys, branch) => keys.filter((key) => branch.properties?.[key] !== undefined),
+        Object.keys(branches[0].properties ?? {})
+      )
+      properties = Object.fromEntries(shared.map((key) => [key, branches[0].properties[key]]))
+      required = new Set(shared.filter((key) => branches.every((b) => b.required?.includes(key))))
+    }
+  }
+
   const keys = Object.keys(properties)
 
-  // A union body (e.g. single-row vs batch insert) has no flat field list; the
-  // runtime falls back to taking the whole body as JSON.
+  // A union body (e.g. single-row vs batch insert) has no flat field list. The
+  // caller marks it `opaqueBody` so the runtime can offer the whole body as one
+  // JSON flag instead.
   if (keys.length === 0) return null
 
   const lines = keys.map((key) => {
@@ -441,6 +471,13 @@ function render(operations: Operation[]): string {
     for (const slot of ['query', 'body'] as const) {
       const map = renderSlotMap(op.contract[slot], '    ')
       if (map) out.push(`    ${slot}: ${map},`)
+      // A declared slot with no flat field list still has to be sendable.
+      // Absence alone cannot say so: it means both "no body" and "a body the
+      // generator could not describe", and reading it as the former left
+      // `tables rows create` unable to send anything at all.
+      if (slot === 'body' && op.contract.body && isUnionSlot(op.contract.body)) {
+        out.push(`    opaqueBody: true,`)
+      }
     }
     out.push('  },')
   }