ts-procedures 5.9.1 → 5.10.2

package/src/client/call.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi } from 'vitest'
+import { executeCall } from './call.js'
+import { ClientRequestError } from './errors.js'
+import type {
+  ClientAdapter,
+  AdapterRequest,
+  AdapterResponse,
+  ClientHooks,
+  CallDescriptor,
+} from './types.js'
+
+// ── helpers ───────────────────────────────────────────────
+
+function makeDescriptor(overrides?: Partial<CallDescriptor>): CallDescriptor {
+  return {
+    name: 'GetUser',
+    scope: 'users',
+    path: '/users',
+    method: 'GET',
+    kind: 'rpc',
+    params: { id: '42' },
+    ...overrides,
+  }
+}
+
+function makeAdapter(response?: Partial<AdapterResponse>): ClientAdapter {
+  return {
+    request: vi.fn(async (_req: AdapterRequest): Promise<AdapterResponse> => ({
+      status: 200,
+      headers: {},
+      body: { id: '42', name: 'Alice' },
+      ...response,
+    })),
+    stream: vi.fn(async () => {
+      throw new Error('stream not expected in call tests')
+    }),
+  }
+}
+
+// ── executeCall ───────────────────────────────────────────
+
+describe('executeCall', () => {
+  it('calls adapter.request and returns body', async () => {
+    const adapter = makeAdapter({ body: { id: '1', name: 'Bob' } })
+    const result = await executeCall(makeDescriptor(), 'https://api.example.com', adapter, {}, undefined)
+    expect(adapter.request).toHaveBeenCalledOnce()
+    expect(result).toEqual({ id: '1', name: 'Bob' })
+  })
+
+  it('throws ClientRequestError on 4xx response', async () => {
+    const adapter = makeAdapter({ status: 404, body: { message: 'Not Found' } })
+    await expect(
+      executeCall(makeDescriptor(), 'https://api.example.com', adapter, {}, undefined)
+    ).rejects.toThrow(ClientRequestError)
+  })
+
+  it('throws ClientRequestError on 5xx response', async () => {
+    const adapter = makeAdapter({ status: 500, body: { message: 'Server Error' } })
+    await expect(
+      executeCall(makeDescriptor(), 'https://api.example.com', adapter, {}, undefined)
+    ).rejects.toThrow(ClientRequestError)
+  })
+
+  it('throws ClientRequestError on 199 response (below 200)', async () => {
+    const adapter = makeAdapter({ status: 199, body: null })
+    await expect(
+      executeCall(makeDescriptor(), 'https://api.example.com', adapter, {}, undefined)
+    ).rejects.toThrow(ClientRequestError)
+  })
+
+  it('does not throw on 2xx boundary responses (200, 201, 299)', async () => {
+    for (const status of [200, 201, 204, 299]) {
+      const adapter = makeAdapter({ status, body: null })
+      await expect(
+        executeCall(makeDescriptor(), 'https://api.example.com', adapter, {}, undefined)
+      ).resolves.not.toThrow()
+    }
+  })
+
+  it('runs onBeforeRequest before calling adapter (headers are modified)', async () => {
+    const capturedHeaders: Record<string, string>[] = []
+    const adapter: ClientAdapter = {
+      request: vi.fn(async (req: AdapterRequest): Promise<AdapterResponse> => {
+        capturedHeaders.push(req.headers ?? {})
+        return { status: 200, headers: {}, body: {} }
+      }),
+      stream: vi.fn(async () => { throw new Error('not expected') }),
+    }
+
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({
+        ...ctx,
+        request: {
+          ...ctx.request,
+          headers: { ...ctx.request.headers, 'x-auth': 'token-123' },
+        },
+      }),
+    }
+
+    await executeCall(makeDescriptor(), 'https://api.example.com', adapter, globalHooks, undefined)
+    expect(capturedHeaders[0]?.['x-auth']).toBe('token-123')
+  })
+
+  it('runs onAfterResponse after adapter returns', async () => {
+    const order: string[] = []
+    const adapter: ClientAdapter = {
+      request: vi.fn(async (): Promise<AdapterResponse> => {
+        order.push('adapter')
+        return { status: 200, headers: {}, body: {} }
+      }),
+      stream: vi.fn(async () => { throw new Error('not expected') }),
+    }
+    const globalHooks: ClientHooks = {
+      onAfterResponse: () => { order.push('afterResponse') },
+    }
+
+    await executeCall(makeDescriptor(), 'https://api.example.com', adapter, globalHooks, undefined)
+    expect(order).toEqual(['adapter', 'afterResponse'])
+  })
+
+  it('does not throw when onAfterResponse swallows non-2xx by mutating status', async () => {
+    const adapter = makeAdapter({ status: 401, body: { message: 'Unauthorized' } })
+    const globalHooks: ClientHooks = {
+      onAfterResponse: (ctx) => {
+        // Swallow the error by setting status to 200
+        ctx.response.status = 200
+      },
+    }
+
+    await expect(
+      executeCall(makeDescriptor(), 'https://api.example.com', adapter, globalHooks, undefined)
+    ).resolves.not.toThrow()
+  })
+
+  it('runs onError on adapter failure and re-throws', async () => {
+    const adapterError = new Error('Network failure')
+    const adapter: ClientAdapter = {
+      request: vi.fn(async () => { throw adapterError }),
+      stream: vi.fn(async () => { throw new Error('not expected') }),
+    }
+    const receivedErrors: unknown[] = []
+    const globalHooks: ClientHooks = {
+      onError: (ctx) => { receivedErrors.push(ctx.error) },
+    }
+
+    await expect(
+      executeCall(makeDescriptor(), 'https://api.example.com', adapter, globalHooks, undefined)
+    ).rejects.toThrow('Network failure')
+    expect(receivedErrors[0]).toBe(adapterError)
+  })
+
+  it('passes per-procedure hooks as local hooks', async () => {
+    const adapter = makeAdapter()
+    const localOrder: string[] = []
+    const localHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => { localOrder.push('local-before'); return ctx },
+    }
+
+    await executeCall(makeDescriptor(), 'https://api.example.com', adapter, {}, localHooks)
+    expect(localOrder).toContain('local-before')
+  })
+})

package/src/client/errors.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest'
+import { ClientRequestError, ClientPathParamError, ClientStreamError } from './errors.js'
+
+describe('ClientRequestError', () => {
+  it('includes status, headers, and body', () => {
+    const err = new ClientRequestError({
+      status: 401,
+      headers: { 'x-request-id': 'abc' },
+      body: { message: 'Unauthorized' },
+      procedureName: 'GetUser',
+      scope: 'users',
+    })
+    expect(err).toBeInstanceOf(Error)
+    expect(err.name).toBe('ClientRequestError')
+    expect(err.status).toBe(401)
+    expect(err.headers['x-request-id']).toBe('abc')
+    expect(err.body).toEqual({ message: 'Unauthorized' })
+    expect(err.procedureName).toBe('GetUser')
+    expect(err.scope).toBe('users')
+    expect(err.message).toBe('GetUser (users) failed with status 401')
+  })
+})
+
+describe('ClientPathParamError', () => {
+  it('reports missing param', () => {
+    const err = new ClientPathParamError('id', '/users/:id', 'GetUser')
+    expect(err).toBeInstanceOf(Error)
+    expect(err.name).toBe('ClientPathParamError')
+    expect(err.message).toContain('id')
+    expect(err.message).toContain('/users/:id')
+  })
+})
+
+describe('ClientStreamError', () => {
+  it('includes procedure context', () => {
+    const err = new ClientStreamError('stream interrupted', 'Watch', 'events')
+    expect(err).toBeInstanceOf(Error)
+    expect(err.name).toBe('ClientStreamError')
+    expect(err.procedureName).toBe('Watch')
+    expect(err.scope).toBe('events')
+    expect(err.message).toBe('stream interrupted')
+  })
+})

package/src/client/fetch-adapter.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createFetchAdapter } from './fetch-adapter.js'
+
+// ── helpers ───────────────────────────────────────────────
+
+function mockSSEResponse(sseText: string): Response {
+  const encoder = new TextEncoder()
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(sseText))
+      controller.close()
+    },
+  })
+  return new Response(stream, {
+    status: 200,
+    headers: { 'content-type': 'text/event-stream' },
+  })
+}
+
+function mockSSEResponseChunked(chunks: string[]): Response {
+  const encoder = new TextEncoder()
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(encoder.encode(chunk))
+      }
+      controller.close()
+    },
+  })
+  return new Response(stream, {
+    status: 200,
+    headers: { 'content-type': 'text/event-stream' },
+  })
+}
+
+async function collectStream(stream: AsyncIterable<unknown>): Promise<unknown[]> {
+  const items: unknown[] = []
+  for await (const item of stream) {
+    items.push(item)
+  }
+  return items
+}
+
+// ── request() tests ───────────────────────────────────────
+
+describe('createFetchAdapter — request()', () => {
+  beforeEach(() => {
+    vi.stubGlobal('fetch', vi.fn())
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('makes fetch call with correct URL, method, body', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({ id: 1 }), { status: 200 })
+    )
+
+    const adapter = createFetchAdapter()
+    await adapter.request({
+      url: 'https://api.example.com/users',
+      method: 'POST',
+      body: { name: 'Alice' },
+    })
+
+    expect(mockFetch).toHaveBeenCalledOnce()
+    const [url, init] = mockFetch.mock.calls[0]!
+    expect(url).toBe('https://api.example.com/users')
+    expect((init as Record<string, unknown>).method).toBe('POST')
+    expect((init as Record<string, unknown>).body).toBe(JSON.stringify({ name: 'Alice' }))
+  })
+
+  it('merges config headers with request headers (request wins)', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 })
+    )
+
+    const adapter = createFetchAdapter({
+      headers: {
+        'x-api-key': 'default-key',
+        'x-source': 'config',
+      },
+    })
+
+    await adapter.request({
+      url: 'https://api.example.com/data',
+      method: 'GET',
+      headers: {
+        'x-api-key': 'override-key', // should win
+        'x-request-id': 'abc123',
+      },
+    })
+
+    const [, init] = mockFetch.mock.calls[0]!
+    const headers = (init as Record<string, unknown>).headers as Record<string, string>
+    expect(headers['x-api-key']).toBe('override-key')
+    expect(headers['x-source']).toBe('config')
+    expect(headers['x-request-id']).toBe('abc123')
+  })
+
+  it('parses JSON response body', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({ result: 'ok' }), { status: 200 })
+    )
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.request({
+      url: 'https://api.example.com/ping',
+      method: 'GET',
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.body).toEqual({ result: 'ok' })
+  })
+
+  it('handles empty/non-JSON response body gracefully (e.g. 204 No Content)', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(new Response(null, { status: 204 }))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.request({
+      url: 'https://api.example.com/delete',
+      method: 'DELETE',
+    })
+
+    expect(response.status).toBe(204)
+    // body should be null (or empty string) — not throw
+    expect(response.body === null || response.body === '').toBe(true)
+  })
+
+  it('passes signal to fetch', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 })
+    )
+
+    const controller = new AbortController()
+    const adapter = createFetchAdapter()
+    await adapter.request({
+      url: 'https://api.example.com/slow',
+      method: 'GET',
+      signal: controller.signal,
+    })
+
+    const [, init] = mockFetch.mock.calls[0]!
+    expect((init as Record<string, unknown>).signal).toBe(controller.signal)
+  })
+
+  it('returns response headers as Record<string, string>', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { 'content-type': 'application/json', 'x-request-id': 'xyz' },
+      })
+    )
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.request({
+      url: 'https://api.example.com/data',
+      method: 'GET',
+    })
+
+    expect(response.headers['content-type']).toBe('application/json')
+    expect(response.headers['x-request-id']).toBe('xyz')
+  })
+
+  it('sends no body when body is undefined', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(new Response(JSON.stringify({}), { status: 200 }))
+
+    const adapter = createFetchAdapter()
+    await adapter.request({
+      url: 'https://api.example.com/items',
+      method: 'GET',
+    })
+
+    const [, init] = mockFetch.mock.calls[0]!
+    expect((init as Record<string, unknown>).body).toBeUndefined()
+  })
+})
+
+// ── stream() tests ────────────────────────────────────────
+
+describe('createFetchAdapter — stream()', () => {
+  beforeEach(() => {
+    vi.stubGlobal('fetch', vi.fn())
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('parses SSE events from stream', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    const sseText =
+      'event: message\ndata: {"count":1}\nid: 0\n\nevent: message\ndata: {"count":2}\nid: 1\n\n'
+    mockFetch.mockResolvedValueOnce(mockSSEResponse(sseText))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    expect(response.status).toBe(200)
+    const items = await collectStream(response.body)
+    expect(items).toEqual([
+      { data: { count: 1 }, event: 'message', id: '0' },
+      { data: { count: 2 }, event: 'message', id: '1' },
+    ])
+  })
+
+  it('handles multi-line data fields (multiple data: lines joined with newline)', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    // Multi-line data: per SSE spec, multiple data: lines are joined with \n
+    const sseText = 'event: multi\ndata: {"line":\ndata: "hello"}\n\n'
+    mockFetch.mockResolvedValueOnce(mockSSEResponse(sseText))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    const items = await collectStream(response.body)
+    expect(items).toHaveLength(1)
+    const item = items[0] as { data: unknown; event: string }
+    expect(item.event).toBe('multi')
+    // data is parsed from joined lines: '{"line":\n"hello"}'
+    expect(item.data).toEqual({ line: 'hello' })
+  })
+
+  it('handles chunked SSE data (message split across multiple chunks)', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    // Split the SSE message across 3 chunks
+    const chunks = [
+      'event: tick\nda',
+      'ta: {"n":42}\n',
+      '\n',
+    ]
+    mockFetch.mockResolvedValueOnce(mockSSEResponseChunked(chunks))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    const items = await collectStream(response.body)
+    expect(items).toEqual([{ data: { n: 42 }, event: 'tick', id: undefined }])
+  })
+
+  it('yields parsed objects with event and id', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    const sseText = 'event: update\ndata: {"value":7}\nid: evt-99\n\n'
+    mockFetch.mockResolvedValueOnce(mockSSEResponse(sseText))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    const items = await collectStream(response.body)
+    expect(items).toEqual([{ data: { value: 7 }, event: 'update', id: 'evt-99' }])
+  })
+
+  it('handles event: return correctly (just another SSE event)', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    const sseText =
+      'event: message\ndata: {"n":1}\n\nevent: return\ndata: {"total":10}\n\n'
+    mockFetch.mockResolvedValueOnce(mockSSEResponse(sseText))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    // The adapter yields all SSE events as-is — createTypedStream handles 'return' semantics
+    const items = await collectStream(response.body)
+    expect(items).toEqual([
+      { data: { n: 1 }, event: 'message', id: undefined },
+      { data: { total: 10 }, event: 'return', id: undefined },
+    ])
+  })
+
+  it('returns response headers from stream response', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(
+      mockSSEResponse('event: ping\ndata: {}\n\n')
+    )
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    expect(response.headers['content-type']).toContain('text/event-stream')
+  })
+
+  it('passes signal to fetch for streams', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    mockFetch.mockResolvedValueOnce(mockSSEResponse('event: ping\ndata: {}\n\n'))
+
+    const controller = new AbortController()
+    const adapter = createFetchAdapter()
+    await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+      signal: controller.signal,
+    })
+
+    const [, init] = mockFetch.mock.calls[0]!
+    expect((init as Record<string, unknown>).signal).toBe(controller.signal)
+  })
+
+  it('handles SSE events without data field gracefully (skips them)', async () => {
+    const mockFetch = vi.mocked(globalThis.fetch)
+    // Comment-only message (no data field) — should be skipped
+    const sseText = ': keep-alive\n\nevent: message\ndata: {"ok":true}\n\n'
+    mockFetch.mockResolvedValueOnce(mockSSEResponse(sseText))
+
+    const adapter = createFetchAdapter()
+    const response = await adapter.stream({
+      url: 'https://api.example.com/stream',
+      method: 'GET',
+    })
+
+    const items = await collectStream(response.body)
+    // Only the message with data is yielded; comment-only block is skipped
+    expect(items).toEqual([{ data: { ok: true }, event: 'message', id: undefined }])
+  })
+})