ts-procedures 5.9.1 → 5.10.0

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 }])
+  })
+})

package/src/client/hooks.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi } from 'vitest'
+import { runBeforeRequest, runAfterResponse, runOnError } from './hooks.js'
+import type {
+  BeforeRequestContext,
+  AfterResponseContext,
+  ErrorContext,
+  ClientHooks,
+} from './types.js'
+
+// ── helpers ───────────────────────────────────────────────
+
+function makeBeforeCtx(overrides?: Partial<BeforeRequestContext>): BeforeRequestContext {
+  return {
+    procedureName: 'TestProcedure',
+    scope: 'test',
+    request: { url: 'https://example.com', method: 'GET' },
+    ...overrides,
+  }
+}
+
+function makeAfterCtx(overrides?: Partial<AfterResponseContext>): AfterResponseContext {
+  return {
+    procedureName: 'TestProcedure',
+    scope: 'test',
+    request: { url: 'https://example.com', method: 'GET' },
+    response: { status: 200, headers: {}, body: null },
+    ...overrides,
+  }
+}
+
+function makeErrorCtx(overrides?: Partial<ErrorContext>): ErrorContext {
+  return {
+    procedureName: 'TestProcedure',
+    scope: 'test',
+    request: { url: 'https://example.com', method: 'GET' },
+    error: new Error('something went wrong'),
+    ...overrides,
+  }
+}
+
+// ── runBeforeRequest ──────────────────────────────────────
+
+describe('runBeforeRequest', () => {
+  it('runs global hook then local hook in order', async () => {
+    const order: string[] = []
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => { order.push('global'); return ctx },
+    }
+    const localHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => { order.push('local'); return ctx },
+    }
+    const ctx = makeBeforeCtx()
+    await runBeforeRequest(ctx, globalHooks, localHooks)
+    expect(order).toEqual(['global', 'local'])
+  })
+
+  it('passes the (possibly mutated) context from global to local', async () => {
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({
+        ...ctx,
+        request: { ...ctx.request, url: 'https://mutated.example.com' },
+      }),
+    }
+    let receivedUrl = ''
+    const localHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => { receivedUrl = ctx.request.url; return ctx },
+    }
+    const ctx = makeBeforeCtx()
+    await runBeforeRequest(ctx, globalHooks, localHooks)
+    expect(receivedUrl).toBe('https://mutated.example.com')
+  })
+
+  it('returns the final mutated context', async () => {
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({ ...ctx, scope: 'mutated-by-global' }),
+    }
+    const localHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({ ...ctx, scope: ctx.scope + '-then-local' }),
+    }
+    const ctx = makeBeforeCtx()
+    const result = await runBeforeRequest(ctx, globalHooks, localHooks)
+    expect(result.scope).toBe('mutated-by-global-then-local')
+  })
+
+  it('handles async hooks', async () => {
+    const order: string[] = []
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: async (ctx) => { order.push('global'); return ctx },
+    }
+    const localHooks: ClientHooks = {
+      onBeforeRequest: async (ctx) => { order.push('local'); return ctx },
+    }
+    await runBeforeRequest(makeBeforeCtx(), globalHooks, localHooks)
+    expect(order).toEqual(['global', 'local'])
+  })
+
+  it('skips undefined global hook gracefully', async () => {
+    const localHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({ ...ctx, scope: 'local-only' }),
+    }
+    const result = await runBeforeRequest(makeBeforeCtx(), {}, localHooks)
+    expect(result.scope).toBe('local-only')
+  })
+
+  it('skips undefined local hook gracefully', async () => {
+    const globalHooks: ClientHooks = {
+      onBeforeRequest: (ctx) => ({ ...ctx, scope: 'global-only' }),
+    }
+    const result = await runBeforeRequest(makeBeforeCtx(), globalHooks, undefined)
+    expect(result.scope).toBe('global-only')
+  })
+
+  it('skips both hooks gracefully when neither defined', async () => {
+    const ctx = makeBeforeCtx()
+    const result = await runBeforeRequest(ctx, {}, undefined)
+    expect(result).toEqual(ctx)
+  })
+})
+
+// ── runAfterResponse ──────────────────────────────────────
+
+describe('runAfterResponse', () => {
+  it('runs global then local hook', async () => {
+    const order: string[] = []
+    const globalHooks: ClientHooks = { onAfterResponse: () => { order.push('global') } }
+    const localHooks: ClientHooks = { onAfterResponse: () => { order.push('local') } }
+    await runAfterResponse(makeAfterCtx(), globalHooks, localHooks)
+    expect(order).toEqual(['global', 'local'])
+  })
+
+  it('handles async hooks', async () => {
+    const order: string[] = []
+    const globalHooks: ClientHooks = {
+      onAfterResponse: async () => { order.push('global') },
+    }
+    const localHooks: ClientHooks = {
+      onAfterResponse: async () => { order.push('local') },
+    }
+    await runAfterResponse(makeAfterCtx(), globalHooks, localHooks)
+    expect(order).toEqual(['global', 'local'])
+  })
+
+  it('skips undefined hooks gracefully', async () => {
+    // Should not throw
+    await runAfterResponse(makeAfterCtx(), {}, undefined)
+  })
+
+  it('returns void', async () => {
+    const result = await runAfterResponse(makeAfterCtx(), {}, undefined)
+    expect(result).toBeUndefined()
+  })
+})
+
+// ── runOnError ────────────────────────────────────────────
+
+describe('runOnError', () => {
+  it('runs global then local hook', async () => {
+    const order: string[] = []
+    const globalHooks: ClientHooks = { onError: () => { order.push('global') } }
+    const localHooks: ClientHooks = { onError: () => { order.push('local') } }
+    await runOnError(makeErrorCtx(), globalHooks, localHooks)
+    expect(order).toEqual(['global', 'local'])
+  })
+
+  it('handles async hooks', async () => {
+    const order: string[] = []
+    const globalHooks: ClientHooks = { onError: async () => { order.push('global') } }
+    const localHooks: ClientHooks = { onError: async () => { order.push('local') } }
+    await runOnError(makeErrorCtx(), globalHooks, localHooks)
+    expect(order).toEqual(['global', 'local'])
+  })
+
+  it('skips undefined hooks gracefully', async () => {
+    await runOnError(makeErrorCtx(), {}, undefined)
+  })
+
+  it('returns void', async () => {
+    const result = await runOnError(makeErrorCtx(), {}, undefined)
+    expect(result).toBeUndefined()
+  })
+
+  it('receives the error in context', async () => {
+    const receivedErrors: unknown[] = []
+    const globalHooks: ClientHooks = {
+      onError: (ctx) => { receivedErrors.push(ctx.error) },
+    }
+    const err = new Error('boom')
+    await runOnError(makeErrorCtx({ error: err }), globalHooks, undefined)
+    expect(receivedErrors[0]).toBe(err)
+  })
+})