ts-procedures 5.9.0 → 5.10.0

package/src/client/stream.test.ts

@@ -0,0 +1,331 @@
+import { describe, it, expect, vi } from 'vitest'
+import { createTypedStream, executeStream } from './stream.js'
+import { ClientRequestError } from './errors.js'
+import type {
+  ClientAdapter,
+  AdapterRequest,
+  AdapterStreamResponse,
+  ClientHooks,
+  StreamDescriptor,
+} from './types.js'
+
+// ── helpers ───────────────────────────────────────────────
+
+function makeDescriptor(overrides?: Partial<StreamDescriptor>): StreamDescriptor {
+  return {
+    name: 'WatchUpdates',
+    scope: 'updates',
+    path: '/stream/updates',
+    method: 'POST',
+    kind: 'stream',
+    streamMode: 'sse',
+    params: {},
+    ...overrides,
+  }
+}
+
+async function* makeAsyncIterable<T>(items: T[]): AsyncIterable<T> {
+  for (const item of items) {
+    yield item
+  }
+}
+
+function makeStreamAdapter(
+  response?: Partial<AdapterStreamResponse>,
+  items?: unknown[]
+): ClientAdapter {
+  return {
+    request: vi.fn(async (): Promise<never> => {
+      throw new Error('request not expected in stream tests')
+    }),
+    stream: vi.fn(async (_req: AdapterRequest): Promise<AdapterStreamResponse> => ({
+      status: 200,
+      headers: {},
+      body: makeAsyncIterable(items ?? []),
+      ...response,
+    })),
+  }
+}
+
+// ── createTypedStream — SSE mode ──────────────────────────
+
+describe('createTypedStream — SSE mode', () => {
+  it('yields data payloads for normal events', async () => {
+    const sseItems = [
+      { data: { count: 1 }, event: 'update' },
+      { data: { count: 2 }, event: 'update' },
+    ]
+    const stream = createTypedStream<{ count: number }, void>(
+      makeAsyncIterable(sseItems),
+      'sse'
+    )
+
+    const received: { count: number }[] = []
+    for await (const item of stream) {
+      received.push(item)
+    }
+    expect(received).toEqual([{ count: 1 }, { count: 2 }])
+  })
+
+  it('captures return event data in .result instead of yielding', async () => {
+    const sseItems = [
+      { data: { count: 1 }, event: 'update' },
+      { data: { total: 99 }, event: 'return' },
+    ]
+    const stream = createTypedStream<{ count: number }, { total: number }>(
+      makeAsyncIterable(sseItems),
+      'sse'
+    )
+
+    const yielded: { count: number }[] = []
+    for await (const item of stream) {
+      yielded.push(item)
+    }
+
+    // Only the 'update' event is yielded
+    expect(yielded).toEqual([{ count: 1 }])
+
+    // The 'return' event resolves .result
+    const result = await stream.result
+    expect(result).toEqual({ total: 99 })
+  })
+
+  it('resolves .result with undefined when no return event', async () => {
+    const sseItems = [
+      { data: 'hello', event: 'message' },
+    ]
+    const stream = createTypedStream<string, undefined>(
+      makeAsyncIterable(sseItems),
+      'sse'
+    )
+
+    for await (const _ of stream) { /* drain */ }
+    const result = await stream.result
+    expect(result).toBeUndefined()
+  })
+
+  it('rejects .result and re-throws on error', async () => {
+    async function* errorIterable(): AsyncIterable<unknown> {
+      yield { data: 'first', event: 'message' }
+      throw new Error('stream broke')
+    }
+
+    const stream = createTypedStream<string, void>(errorIterable(), 'sse')
+
+    // Consuming the stream should throw
+    await expect(async () => {
+      for await (const _ of stream) { /* drain */ }
+    }).rejects.toThrow('stream broke')
+
+    // .result should also reject
+    await expect(stream.result).rejects.toThrow('stream broke')
+  })
+
+  it('handles SSE items without event field (defaults to yielding data)', async () => {
+    const sseItems = [
+      { data: 'a' },
+      { data: 'b' },
+    ]
+    const stream = createTypedStream<string, void>(
+      makeAsyncIterable(sseItems),
+      'sse'
+    )
+
+    const yielded: string[] = []
+    for await (const item of stream) {
+      yielded.push(item)
+    }
+    expect(yielded).toEqual(['a', 'b'])
+  })
+})
+
+// ── createTypedStream — text mode ────────────────────────
+
+describe('createTypedStream — text mode', () => {
+  it('yields each chunk as-is', async () => {
+    const chunks = ['chunk1', 'chunk2', 'chunk3']
+    const stream = createTypedStream<string, void>(
+      makeAsyncIterable(chunks),
+      'text'
+    )
+
+    const received: string[] = []
+    for await (const chunk of stream) {
+      received.push(chunk)
+    }
+    expect(received).toEqual(chunks)
+  })
+
+  it('.result resolves to void on normal completion', async () => {
+    const stream = createTypedStream<string, void>(
+      makeAsyncIterable(['a', 'b']),
+      'text'
+    )
+
+    for await (const _ of stream) { /* drain */ }
+    const result = await stream.result
+    expect(result).toBeUndefined()
+  })
+
+  it('rejects .result and re-throws on error', async () => {
+    async function* errorIterable(): AsyncIterable<string> {
+      yield 'before error'
+      throw new Error('text stream error')
+    }
+
+    const stream = createTypedStream<string, void>(errorIterable(), 'text')
+
+    await expect(async () => {
+      for await (const _ of stream) { /* drain */ }
+    }).rejects.toThrow('text stream error')
+
+    await expect(stream.result).rejects.toThrow('text stream error')
+  })
+})
+
+// ── executeStream ─────────────────────────────────────────
+
+describe('executeStream', () => {
+  it('calls adapter.stream and returns a TypedStream', async () => {
+    const items = [{ data: 'hello', event: 'msg' }]
+    const adapter = makeStreamAdapter({}, items)
+
+    const stream = await executeStream<string, void>(
+      makeDescriptor(),
+      'https://api.example.com',
+      adapter,
+      {},
+      undefined
+    )
+
+    expect(adapter.stream).toHaveBeenCalledOnce()
+    const received: string[] = []
+    for await (const item of stream) {
+      received.push(item)
+    }
+    expect(received).toEqual(['hello'])
+  })
+
+  it('runs onBeforeRequest before calling adapter', async () => {
+    const capturedHeaders: Record<string, string>[] = []
+    const adapter: ClientAdapter = {
+      request: vi.fn(async (): Promise<never> => { throw new Error('not expected') }),
+      stream: vi.fn(async (req: AdapterRequest): Promise<AdapterStreamResponse> => {
+        capturedHeaders.push(req.headers ?? {})
+        return { status: 200, headers: {}, body: makeAsyncIterable([]) }
+      }),
+    }
+
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({
+        ...ctx,
+        request: { ...ctx.request, headers: { 'x-stream-auth': 'stream-token' } },
+      }),
+    }
+
+    const stream = await executeStream(
+      makeDescriptor(),
+      'https://api.example.com',
+      adapter,
+      globalHooks,
+      undefined
+    )
+    // Drain
+    for await (const _ of stream) { /* noop */ }
+
+    expect(capturedHeaders[0]?.['x-stream-auth']).toBe('stream-token')
+  })
+
+  it('runs onAfterResponse immediately (before iteration)', async () => {
+    const order: string[] = []
+    const adapter: ClientAdapter = {
+      request: vi.fn(async (): Promise<never> => { throw new Error('not expected') }),
+      stream: vi.fn(async (): Promise<AdapterStreamResponse> => {
+        order.push('adapter')
+        return { status: 200, headers: {}, body: makeAsyncIterable([]) }
+      }),
+    }
+    const globalHooks: ClientHooks = {
+      onAfterResponse: () => { order.push('afterResponse') },
+    }
+
+    await executeStream(makeDescriptor(), 'https://api.example.com', adapter, globalHooks, undefined)
+    // After executeStream returns (before iteration), afterResponse should have fired
+    expect(order).toEqual(['adapter', 'afterResponse'])
+  })
+
+  it('throws ClientRequestError on non-2xx status', async () => {
+    const adapter: ClientAdapter = {
+      request: vi.fn(async (): Promise<never> => { throw new Error('not expected') }),
+      stream: vi.fn(async (): Promise<AdapterStreamResponse> => ({
+        status: 403,
+        headers: {},
+        body: makeAsyncIterable([]),
+      })),
+    }
+
+    await expect(
+      executeStream(makeDescriptor(), 'https://api.example.com', adapter, {}, undefined)
+    ).rejects.toThrow(ClientRequestError)
+  })
+
+  it('runs onError on adapter failure and re-throws', async () => {
+    const adapterError = new Error('stream connection failed')
+    const adapter: ClientAdapter = {
+      request: vi.fn(async (): Promise<never> => { throw new Error('not expected') }),
+      stream: vi.fn(async () => { throw adapterError }),
+    }
+    const receivedErrors: unknown[] = []
+    const globalHooks: ClientHooks = {
+      onError: (ctx) => { receivedErrors.push(ctx.error) },
+    }
+
+    await expect(
+      executeStream(makeDescriptor(), 'https://api.example.com', adapter, globalHooks, undefined)
+    ).rejects.toThrow('stream connection failed')
+    expect(receivedErrors[0]).toBe(adapterError)
+  })
+
+  it('returns TypedStream with working .result for SSE return event', async () => {
+    const sseItems = [
+      { data: { n: 1 }, event: 'tick' },
+      { data: { final: true }, event: 'return' },
+    ]
+    const adapter = makeStreamAdapter({}, sseItems)
+
+    const stream = await executeStream<{ n: number }, { final: boolean }>(
+      makeDescriptor({ streamMode: 'sse' }),
+      'https://api.example.com',
+      adapter,
+      {},
+      undefined
+    )
+
+    const yielded: { n: number }[] = []
+    for await (const item of stream) {
+      yielded.push(item)
+    }
+    expect(yielded).toEqual([{ n: 1 }])
+    await expect(stream.result).resolves.toEqual({ final: true })
+  })
+
+  it('returns TypedStream for text mode', async () => {
+    const chunks = ['line1', 'line2']
+    const adapter = makeStreamAdapter({}, chunks)
+
+    const stream = await executeStream<string, void>(
+      makeDescriptor({ streamMode: 'text' }),
+      'https://api.example.com',
+      adapter,
+      {},
+      undefined
+    )
+
+    const received: string[] = []
+    for await (const chunk of stream) {
+      received.push(chunk)
+    }
+    expect(received).toEqual(chunks)
+    await expect(stream.result).resolves.toBeUndefined()
+  })
+})

package/src/codegen/bin/cli.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect } from 'vitest'
+import { parseArgs, loadConfigFile, extractConfigPath, type CodegenConfig } from './cli.js'
+
+describe('parseArgs', () => {
+  it('parses --url and --out', () => {
+    const result = parseArgs(['--url', 'http://localhost:3000/docs', '--out', './generated'])
+    expect(result.url).toBe('http://localhost:3000/docs')
+    expect(result.outDir).toBe('./generated')
+    expect(result.file).toBeUndefined()
+  })
+
+  it('parses --file and --out', () => {
+    const result = parseArgs(['--file', './envelope.json', '--out', './generated'])
+    expect(result.file).toBe('./envelope.json')
+    expect(result.outDir).toBe('./generated')
+    expect(result.url).toBeUndefined()
+  })
+
+  it('parses --enum-style union', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--enum-style', 'union'])
+    expect(result.ajsc?.enumStyle).toBe('union')
+  })
+
+  it('parses --enum-style enum', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--enum-style', 'enum'])
+    expect(result.ajsc?.enumStyle).toBe('enum')
+  })
+
+  it('parses --depluralize flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--depluralize'])
+    expect(result.ajsc?.depluralize).toBe(true)
+  })
+
+  it('parses --watch flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--watch'])
+    expect(result.watch).toBe(true)
+  })
+
+  it('parses --interval value', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--watch', '--interval', '5000'])
+    expect(result.interval).toBe(5000)
+  })
+
+  it('defaults watch to false when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.watch).toBe(false)
+  })
+
+  it('defaults interval to 3000 when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.interval).toBe(3000)
+  })
+
+  it('throws when --out is missing', () => {
+    expect(() => parseArgs(['--url', 'http://x.com/docs'])).toThrow(/--out/)
+  })
+
+  it('throws when no input source (neither --url nor --file)', () => {
+    expect(() => parseArgs(['--out', './generated'])).toThrow(/--url.*--file|--file.*--url|input/i)
+  })
+
+  it('parses all flags together', () => {
+    const result = parseArgs([
+      '--file', './envelope.json',
+      '--out', './generated',
+      '--enum-style', 'union',
+      '--depluralize',
+      '--watch',
+      '--interval', '10000',
+    ])
+    expect(result.file).toBe('./envelope.json')
+    expect(result.outDir).toBe('./generated')
+    expect(result.ajsc?.enumStyle).toBe('union')
+    expect(result.ajsc?.depluralize).toBe(true)
+    expect(result.watch).toBe(true)
+    expect(result.interval).toBe(10000)
+  })
+
+  it('parses --client-import-path flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--client-import-path', '@my-app/client'])
+    expect(result.clientImportPath).toBe('@my-app/client')
+  })
+
+  it('defaults clientImportPath to undefined when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.clientImportPath).toBeUndefined()
+  })
+
+  it('parses --dry-run flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--dry-run'])
+    expect(result.dryRun).toBe(true)
+  })
+
+  it('defaults dryRun to false when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.dryRun).toBe(false)
+  })
+
+  it('parses --namespace-types flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--namespace-types'])
+    expect(result.namespaceTypes).toBe(true)
+  })
+
+  it('defaults namespaceTypes to true when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.namespaceTypes).toBe(true)
+  })
+
+  it('parses --no-namespace-types flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--no-namespace-types'])
+    expect(result.namespaceTypes).toBe(false)
+  })
+
+  it('defaults ajsc.jsdoc to true when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.ajsc?.jsdoc).toBe(true)
+  })
+
+  it('parses --jsdoc flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--jsdoc'])
+    expect(result.ajsc?.jsdoc).toBe(true)
+  })
+
+  it('parses --no-jsdoc flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--no-jsdoc'])
+    expect(result.ajsc?.jsdoc).toBe(false)
+  })
+
+  it('parses --array-item-naming with a string value', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--array-item-naming', 'Item'])
+    expect(result.ajsc?.arrayItemNaming).toBe('Item')
+  })
+
+  it('parses --array-item-naming false to disable', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--array-item-naming', 'false'])
+    expect(result.ajsc?.arrayItemNaming).toBe(false)
+  })
+
+  it('parses --uncountable-words as comma-separated list', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--uncountable-words', 'criteria,alumni,corpus'])
+    expect(result.ajsc?.uncountableWords).toEqual(['criteria', 'alumni', 'corpus'])
+  })
+
+  it('trims whitespace in --uncountable-words', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--uncountable-words', ' data , info '])
+    expect(result.ajsc?.uncountableWords).toEqual(['data', 'info'])
+  })
+
+  it('parses --self-contained flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--self-contained'])
+    expect(result.selfContained).toBe(true)
+  })
+
+  it('defaults selfContained to true when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.selfContained).toBe(true)
+  })
+
+  it('parses --no-self-contained flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--no-self-contained'])
+    expect(result.selfContained).toBe(false)
+  })
+
+  it('parses --service-name flag', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out', '--service-name', 'Auth'])
+    expect(result.serviceName).toBe('Auth')
+  })
+
+  it('defaults serviceName to undefined when not provided', () => {
+    const result = parseArgs(['--url', 'http://x.com/docs', '--out', './out'])
+    expect(result.serviceName).toBeUndefined()
+  })
+})
+
+describe('config file support', () => {
+  it('parseArgs uses config as defaults', () => {
+    const config: CodegenConfig = {
+      url: 'http://config.com/docs',
+      outDir: './config-out',
+      namespaceTypes: true,
+      ajsc: { enumStyle: 'enum', depluralize: true },
+    }
+    const result = parseArgs([], config)
+    expect(result.url).toBe('http://config.com/docs')
+    expect(result.outDir).toBe('./config-out')
+    expect(result.namespaceTypes).toBe(true)
+    expect(result.ajsc?.enumStyle).toBe('enum')
+    expect(result.ajsc?.depluralize).toBe(true)
+  })
+
+  it('CLI flags override config values', () => {
+    const config: CodegenConfig = {
+      url: 'http://config.com/docs',
+      outDir: './config-out',
+      namespaceTypes: false,
+    }
+    const result = parseArgs(['--url', 'http://override.com/docs', '--out', './override-out', '--namespace-types'], config)
+    expect(result.url).toBe('http://override.com/docs')
+    expect(result.outDir).toBe('./override-out')
+    expect(result.namespaceTypes).toBe(true)
+  })
+
+  it('config file selfContained is used as default', () => {
+    const config: CodegenConfig = {
+      url: 'http://config.com/docs',
+      outDir: './config-out',
+      selfContained: true,
+    }
+    const result = parseArgs([], config)
+    expect(result.selfContained).toBe(true)
+  })
+
+  it('config file serviceName is used as default', () => {
+    const config: CodegenConfig = {
+      url: 'http://config.com/docs',
+      outDir: './config-out',
+      serviceName: 'Auth',
+    }
+    const result = parseArgs([], config)
+    expect(result.serviceName).toBe('Auth')
+  })
+
+  it('CLI --service-name overrides config serviceName', () => {
+    const config: CodegenConfig = {
+      url: 'http://config.com/docs',
+      outDir: './config-out',
+      serviceName: 'Auth',
+    }
+    const result = parseArgs(['--service-name', 'UsersApi'], config)
+    expect(result.serviceName).toBe('UsersApi')
+  })
+
+  it('CLI ajsc flags merge with config ajsc', () => {
+    const config: CodegenConfig = {
+      url: 'http://config.com/docs',
+      outDir: './out',
+      ajsc: { enumStyle: 'enum' },
+    }
+    const result = parseArgs(['--depluralize'], config)
+    expect(result.ajsc?.enumStyle).toBe('enum')
+    expect(result.ajsc?.depluralize).toBe(true)
+  })
+
+  it('extractConfigPath finds --config value', () => {
+    expect(extractConfigPath(['--config', 'my-config.json', '--out', './out'])).toBe('my-config.json')
+  })
+
+  it('extractConfigPath returns undefined when not provided', () => {
+    expect(extractConfigPath(['--out', './out'])).toBeUndefined()
+  })
+
+  it('loadConfigFile returns undefined for non-existent default path', async () => {
+    const result = await loadConfigFile()
+    expect(result).toBeUndefined()
+  })
+
+  it('loadConfigFile throws for explicit non-existent path', async () => {
+    await expect(loadConfigFile('/nonexistent/config.json')).rejects.toThrow('Failed to load config')
+  })
+})