@bigmistqke/rpc 0.1.0

package/test/stream.test.ts

@@ -0,0 +1,351 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { rpc, client, server, isStreamRequest } from '../src/stream/index'
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
+// Helper to create a controllable ReadableStream
+function createControllableStream() {
+  let controller: ReadableStreamDefaultController<Uint8Array>
+  const stream = new ReadableStream<Uint8Array>({
+    start(c) {
+      controller = c
+    },
+  })
+  return {
+    stream,
+    enqueue: (data: string) => controller.enqueue(encoder.encode(data)),
+    close: () => controller.close(),
+  }
+}
+
+// Helper to collect stream output
+async function collectStream(stream: ReadableStream<Uint8Array>): Promise<string[]> {
+  const reader = stream.getReader()
+  const chunks: string[] = []
+  let buffer = ''
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+
+    let newlineIndex
+    while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+      chunks.push(buffer.slice(0, newlineIndex))
+      buffer = buffer.slice(newlineIndex + 1)
+    }
+  }
+
+  return chunks
+}
+
+describe('isStreamRequest', () => {
+  it('should return true for requests with stream header', () => {
+    const request = new Request('http://example.com', {
+      headers: { RPC_STREAM_REQUEST_HEADER: '1' },
+    })
+    expect(isStreamRequest({ request })).toBe(true)
+  })
+
+  it('should return false for requests without stream header', () => {
+    const request = new Request('http://example.com')
+    expect(isStreamRequest({ request })).toBe(false)
+  })
+})
+
+describe('rpc', () => {
+  it('should create proxy and stream', () => {
+    const inputStream = new ReadableStream()
+    const { proxy, stream, closed, onClose } = rpc(inputStream, {})
+
+    expect(proxy).toBeDefined()
+    expect(stream).toBeInstanceOf(ReadableStream)
+    expect(typeof closed).toBe('function')
+    expect(typeof onClose).toBe('function')
+  })
+
+  it('should handle bidirectional communication', async () => {
+    // Create two connected RPC endpoints
+    const { stream: stream1, enqueue: enqueue1, close: close1 } = createControllableStream()
+    const { stream: stream2, enqueue: enqueue2, close: close2 } = createControllableStream()
+
+    const methods1 = {
+      ping: () => 'pong',
+    }
+
+    const methods2 = {
+      echo: (msg: string) => msg,
+    }
+
+    // Set up endpoint 1 - reads from stream1, writes to its output stream
+    const endpoint1 = rpc<{ echo: (msg: string) => string }, typeof methods1>(
+      stream1,
+      methods1,
+    )
+
+    // Set up endpoint 2 - reads from stream2, writes to its output stream
+    const endpoint2 = rpc<{ ping: () => string }, typeof methods2>(stream2, methods2)
+
+    // Connect the streams: endpoint1's output goes to endpoint2's input and vice versa
+    // This simulates the bidirectional connection
+    const reader1 = endpoint1.stream.getReader()
+    const reader2 = endpoint2.stream.getReader()
+
+    // Forward messages from endpoint1 to endpoint2
+    ;(async () => {
+      while (true) {
+        const { done, value } = await reader1.read()
+        if (done) break
+        enqueue2(decoder.decode(value))
+      }
+    })()
+
+    // Forward messages from endpoint2 to endpoint1
+    ;(async () => {
+      while (true) {
+        const { done, value } = await reader2.read()
+        if (done) break
+        enqueue1(decoder.decode(value))
+      }
+    })()
+
+    // Test RPC calls
+    const pingResult = await endpoint2.proxy.ping()
+    expect(pingResult).toBe('pong')
+
+    const echoResult = await endpoint1.proxy.echo('hello')
+    expect(echoResult).toBe('hello')
+  })
+
+  it('should serialize requests as JSON lines', async () => {
+    const inputStream = new ReadableStream()
+    const { proxy, stream } = rpc<{ test: () => void }>(inputStream, {})
+
+    // Get reader before making request
+    const reader = stream.getReader()
+    const decoder = new TextDecoder()
+
+    // Make a request (don't await - it will hang since there's no response)
+    proxy.test()
+
+    // Read the first chunk
+    const { value, done } = await reader.read()
+    expect(done).toBe(false)
+    expect(value).toBeInstanceOf(Uint8Array)
+
+    // Verify it's JSON line format (ends with newline)
+    const text = decoder.decode(value)
+    expect(text.endsWith('\n')).toBe(true)
+
+    // Should be valid JSON
+    const parsed = JSON.parse(text.trim())
+    expect(parsed).toHaveProperty('RPC_PROXY_REQUEST')
+    expect(parsed).toHaveProperty('payload')
+
+    reader.releaseLock()
+  })
+
+  it('should throw when stream is closed', async () => {
+    const { stream: inputStream, close } = createControllableStream()
+    const { proxy, closed, stream } = rpc<{ test: () => void }>(inputStream, {})
+
+    // Cancel the output stream to trigger closed state
+    const reader = stream.getReader()
+    await reader.cancel()
+
+    // Now the closed() should return true and proxy calls should throw
+    expect(closed()).toBe(true)
+    await expect(proxy.test()).rejects.toThrow('[rpc/sse] Stream is closed.')
+  })
+
+  it('should accept stream from function', async () => {
+    const inputStream = new ReadableStream()
+    const streamFactory = vi.fn((outputStream: ReadableStream) => inputStream)
+
+    const { proxy, stream } = rpc(streamFactory, {})
+
+    expect(streamFactory).toHaveBeenCalledWith(stream)
+  })
+
+  it('should accept stream from promise', async () => {
+    const inputStream = new ReadableStream()
+    const streamPromise = Promise.resolve(inputStream)
+
+    const { proxy } = rpc(streamPromise, {})
+
+    expect(proxy).toBeDefined()
+  })
+
+  it('should use custom codec when provided', async () => {
+    const { stream: inputStream, enqueue, close } = createControllableStream()
+
+    const customCodec = {
+      serialize: vi.fn((value: any, onChunk: (chunk: any) => void) => {
+        onChunk(encoder.encode(`CUSTOM:${JSON.stringify(value)}\n`))
+      }),
+      deserialize: vi.fn(async (stream: ReadableStream, onChunk: (chunk: any) => void) => {
+        for await (const chunk of stream as unknown as AsyncIterable<Uint8Array>) {
+          const text = decoder.decode(chunk)
+          const lines = text.split('\n').filter(Boolean)
+          for (const line of lines) {
+            if (line.startsWith('CUSTOM:')) {
+              onChunk(JSON.parse(line.slice(7)))
+            }
+          }
+        }
+      }),
+    }
+
+    const { proxy, stream } = rpc<{ test: () => void }>(inputStream, {}, customCodec)
+
+    proxy.test()
+
+    await new Promise(resolve => setTimeout(resolve, 10))
+
+    expect(customCodec.serialize).toHaveBeenCalled()
+    expect(customCodec.deserialize).toHaveBeenCalled()
+  })
+
+  it('should handle nested method calls', async () => {
+    const { stream: stream1, enqueue: enqueue1 } = createControllableStream()
+    const { stream: stream2, enqueue: enqueue2 } = createControllableStream()
+
+    const methods = {
+      user: {
+        profile: {
+          getName: () => 'John Doe',
+        },
+      },
+    }
+
+    const endpoint1 = rpc<typeof methods>(stream1, methods)
+    const endpoint2 = rpc<{}, typeof methods>(stream2, {})
+
+    // Wire up the streams
+    const reader1 = endpoint1.stream.getReader()
+    const reader2 = endpoint2.stream.getReader()
+
+    ;(async () => {
+      while (true) {
+        const { done, value } = await reader1.read()
+        if (done) break
+        enqueue2(decoder.decode(value))
+      }
+    })()
+
+    ;(async () => {
+      while (true) {
+        const { done, value } = await reader2.read()
+        if (done) break
+        enqueue1(decoder.decode(value))
+      }
+    })()
+
+    const result = await endpoint2.proxy.user.profile.getName()
+    expect(result).toBe('John Doe')
+  })
+})
+
+describe('server', () => {
+  it('should create a Response with correct headers', () => {
+    const inputStream = new ReadableStream()
+    const { response } = server(inputStream, {})
+
+    expect(response).toBeInstanceOf(Response)
+    expect(response.headers.get('Content-Type')).toBe('text/event-stream')
+    expect(response.headers.get('Cache-Control')).toBe('no-cache')
+    expect(response.headers.get('Connection')).toBe('keep-alive')
+  })
+
+  it('should expose proxy and lifecycle methods', () => {
+    const inputStream = new ReadableStream()
+    const { proxy, closed, onClose, response } = server(inputStream, {})
+
+    expect(proxy).toBeDefined()
+    expect(typeof closed).toBe('function')
+    expect(typeof onClose).toBe('function')
+    expect(response).toBeInstanceOf(Response)
+  })
+})
+
+describe('client', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    globalThis.fetch = vi.fn()
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('should make POST request with correct headers', async () => {
+    const mockResponseStream = new ReadableStream()
+    vi.mocked(globalThis.fetch).mockResolvedValue({
+      body: mockResponseStream,
+    } as Response)
+
+    const { proxy, stream } = client('http://example.com/rpc', {})
+
+    // Verify fetch was called with correct options
+    await new Promise(resolve => setTimeout(resolve, 10))
+
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      'http://example.com/rpc',
+      expect.objectContaining({
+        method: 'POST',
+        duplex: 'half',
+        headers: expect.objectContaining({
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+          RPC_STREAM_REQUEST_HEADER: '1',
+        }),
+      }),
+    )
+  })
+
+  it('should send output stream as request body', async () => {
+    const mockResponseStream = new ReadableStream()
+    vi.mocked(globalThis.fetch).mockResolvedValue({
+      body: mockResponseStream,
+    } as Response)
+
+    const { stream } = client('http://example.com/rpc', {})
+
+    await new Promise(resolve => setTimeout(resolve, 10))
+
+    const fetchCall = vi.mocked(globalThis.fetch).mock.calls[0]
+    expect(fetchCall[1]?.body).toBeInstanceOf(ReadableStream)
+  })
+})
+
+describe('onClose callback', () => {
+  it('should call onClose handlers when stream is cancelled', async () => {
+    const inputStream = new ReadableStream()
+    const { stream, onClose } = rpc(inputStream, {})
+
+    const handler = vi.fn()
+    onClose(handler)
+
+    const reader = stream.getReader()
+    await reader.cancel()
+
+    expect(handler).toHaveBeenCalled()
+  })
+
+  it('should allow unsubscribing from onClose', async () => {
+    const inputStream = new ReadableStream()
+    const { stream, onClose } = rpc(inputStream, {})
+
+    const handler = vi.fn()
+    const unsubscribe = onClose(handler)
+    unsubscribe()
+
+    const reader = stream.getReader()
+    await reader.cancel()
+
+    expect(handler).not.toHaveBeenCalled()
+  })
+})

package/test/utils.test.ts

@@ -0,0 +1,336 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  createIdAllocator,
+  createIdRegistry,
+  createPromiseRegistry,
+  defer,
+  createCommander,
+  callMethod,
+  createReadableStream,
+  streamToAsyncIterable,
+  createShape,
+} from '../src/utils'
+import * as v from 'valibot'
+
+describe('createIdAllocator', () => {
+  it('should generate sequential IDs starting from 0', () => {
+    const allocator = createIdAllocator()
+    expect(allocator.create()).toBe(0)
+    expect(allocator.create()).toBe(1)
+    expect(allocator.create()).toBe(2)
+  })
+
+  it('should reuse freed IDs', () => {
+    const allocator = createIdAllocator()
+    const id0 = allocator.create()
+    const id1 = allocator.create()
+    const id2 = allocator.create()
+
+    allocator.free(id1)
+    expect(allocator.create()).toBe(1) // Reuses freed ID
+
+    allocator.free(id0)
+    allocator.free(id2)
+    expect(allocator.create()).toBe(2) // LIFO order for freed IDs
+    expect(allocator.create()).toBe(0)
+  })
+
+  it('should continue generating new IDs when no freed IDs available', () => {
+    const allocator = createIdAllocator()
+    allocator.create() // 0
+    allocator.create() // 1
+    allocator.free(0)
+    allocator.create() // reuses 0
+    expect(allocator.create()).toBe(2) // new ID
+  })
+})
+
+describe('createIdRegistry', () => {
+  it('should register values and return IDs', () => {
+    const registry = createIdRegistry<string>()
+    const id0 = registry.register('foo')
+    const id1 = registry.register('bar')
+    expect(id0).toBe(0)
+    expect(id1).toBe(1)
+  })
+
+  it('should free IDs and return stored values', () => {
+    const registry = createIdRegistry<string>()
+    registry.register('foo')
+    registry.register('bar')
+
+    expect(registry.free(0)).toBe('foo')
+    expect(registry.free(1)).toBe('bar')
+  })
+
+  it('should return undefined for non-existent IDs', () => {
+    const registry = createIdRegistry<string>()
+    expect(registry.free(999)).toBeUndefined()
+  })
+
+  it('should reuse freed IDs for new registrations', () => {
+    const registry = createIdRegistry<string>()
+    const id0 = registry.register('foo')
+    registry.free(id0)
+    const id1 = registry.register('bar')
+    expect(id1).toBe(0) // Reused
+  })
+})
+
+describe('createPromiseRegistry', () => {
+  it('should register promise handlers and retrieve them', () => {
+    const registry = createPromiseRegistry()
+    const resolve = vi.fn()
+    const reject = vi.fn()
+
+    const id = registry.register({ resolve, reject })
+    const handlers = registry.free(id)
+
+    expect(handlers).toEqual({ resolve, reject })
+  })
+})
+
+describe('defer', () => {
+  it('should create a deferred promise that can be resolved', async () => {
+    const deferred = defer<string>()
+    deferred.resolve('test')
+    await expect(deferred.promise).resolves.toBe('test')
+  })
+
+  it('should create a deferred promise that can be rejected', async () => {
+    const deferred = defer<string>()
+    deferred.reject(new Error('test error'))
+    await expect(deferred.promise).rejects.toThrow('test error')
+  })
+
+  it('should work with void type', async () => {
+    const deferred = defer()
+    deferred.resolve()
+    await expect(deferred.promise).resolves.toBeUndefined()
+  })
+})
+
+describe('createCommander', () => {
+  it('should track property access as topics', () => {
+    const apply = vi.fn()
+    const commander = createCommander<{ foo: { bar: () => void } }>(apply)
+
+    commander.foo.bar()
+
+    expect(apply).toHaveBeenCalledWith(['foo', 'bar'], [])
+  })
+
+  it('should pass arguments to apply function', () => {
+    const apply = vi.fn()
+    const commander = createCommander<{ method: (a: number, b: string) => void }>(apply)
+
+    commander.method(42, 'hello')
+
+    expect(apply).toHaveBeenCalledWith(['method'], [42, 'hello'])
+  })
+
+  it('should handle deeply nested paths', () => {
+    const apply = vi.fn()
+    const commander = createCommander<{ a: { b: { c: { d: () => void } } } }>(apply)
+
+    commander.a.b.c.d()
+
+    expect(apply).toHaveBeenCalledWith(['a', 'b', 'c', 'd'], [])
+  })
+
+  it('should return undefined for symbol properties', () => {
+    const apply = vi.fn()
+    const commander = createCommander(apply)
+
+    expect((commander as any)[Symbol.iterator]).toBeUndefined()
+  })
+
+  it('should return result from apply function', () => {
+    const apply = vi.fn().mockReturnValue('result')
+    const commander = createCommander<{ method: () => string }>(apply)
+
+    const result = commander.method()
+
+    expect(result).toBe('result')
+  })
+})
+
+describe('callMethod', () => {
+  it('should call top-level method', () => {
+    const methods = {
+      greet: (name: string) => `Hello, ${name}!`,
+    }
+
+    expect(callMethod(methods, ['greet'], ['World'])).toBe('Hello, World!')
+  })
+
+  it('should call nested method', () => {
+    const methods = {
+      user: {
+        profile: {
+          getName: () => 'John',
+        },
+      },
+    }
+
+    expect(callMethod(methods, ['user', 'profile', 'getName'], [])).toBe('John')
+  })
+
+  it('should pass multiple arguments', () => {
+    const methods = {
+      add: (a: number, b: number) => a + b,
+    }
+
+    expect(callMethod(methods, ['add'], [2, 3])).toBe(5)
+  })
+
+  it('should throw if topics do not resolve to a function', () => {
+    const methods = {
+      value: 42,
+    }
+
+    expect(() => callMethod(methods, ['value'], [])).toThrow(
+      'Topics did not resolve to a function: [value]',
+    )
+  })
+
+  it('should throw if intermediate path is undefined', () => {
+    const methods = {
+      foo: {},
+    }
+
+    expect(() => callMethod(methods, ['foo', 'bar', 'baz'], [])).toThrow(
+      'Topics did not resolve to a function: [foo,bar,baz]',
+    )
+  })
+
+  it('should throw for non-existent path', () => {
+    const methods = {}
+
+    expect(() => callMethod(methods, ['nonexistent'], [])).toThrow(
+      'Topics did not resolve to a function: [nonexistent]',
+    )
+  })
+})
+
+describe('createShape', () => {
+  it('should validate values against schema', () => {
+    const shape = createShape(v.object({ name: v.string() }), (name: string) => ({ name }))
+
+    expect(shape.validate({ name: 'test' })).toBe(true)
+    expect(shape.validate({ name: 123 })).toBe(false)
+    expect(shape.validate({})).toBe(false)
+    expect(shape.validate(null)).toBe(false)
+  })
+
+  it('should create valid instances', () => {
+    const shape = createShape(
+      v.object({ id: v.number(), value: v.string() }),
+      (id: number, value: string) => ({ id, value }),
+    )
+
+    const instance = shape.create(1, 'test')
+    expect(instance).toEqual({ id: 1, value: 'test' })
+    expect(shape.validate(instance)).toBe(true)
+  })
+})
+
+describe('createReadableStream', () => {
+  it('should create a readable stream with controller', () => {
+    const { stream, controller } = createReadableStream()
+    expect(stream).toBeInstanceOf(ReadableStream)
+    expect(controller).toBeDefined()
+  })
+
+  it('should allow enqueueing data', async () => {
+    const { stream, enqueue } = createReadableStream()
+
+    enqueue('chunk1')
+    enqueue('chunk2')
+
+    const reader = stream.getReader()
+    expect(await reader.read()).toEqual({ value: 'chunk1', done: false })
+    expect(await reader.read()).toEqual({ value: 'chunk2', done: false })
+  })
+
+  it('should track closed state', () => {
+    const { closed } = createReadableStream()
+    expect(closed()).toBe(false)
+  })
+
+  it('should call onClose handlers when stream is cancelled', async () => {
+    const { stream, onClose } = createReadableStream()
+    const handler = vi.fn()
+
+    onClose(handler)
+
+    const reader = stream.getReader()
+    await reader.cancel()
+
+    expect(handler).toHaveBeenCalled()
+  })
+
+  it('should allow removing onClose handlers', async () => {
+    const { stream, onClose } = createReadableStream()
+    const handler = vi.fn()
+
+    const unsubscribe = onClose(handler)
+    unsubscribe()
+
+    const reader = stream.getReader()
+    await reader.cancel()
+
+    expect(handler).not.toHaveBeenCalled()
+  })
+})
+
+describe('streamToAsyncIterable', () => {
+  it('should convert ReadableStream to AsyncIterable', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(1)
+        controller.enqueue(2)
+        controller.enqueue(3)
+        controller.close()
+      },
+    })
+
+    const iterable = streamToAsyncIterable(stream)
+    const results: number[] = []
+
+    for await (const value of iterable) {
+      results.push(value)
+    }
+
+    expect(results).toEqual([1, 2, 3])
+  })
+
+  it('should use native async iterator if available', async () => {
+    const mockStream = {
+      [Symbol.asyncIterator]: function* () {
+        yield 1
+        yield 2
+      },
+    } as unknown as ReadableStream<number>
+
+    const iterable = streamToAsyncIterable(mockStream)
+    expect(iterable).toBe(mockStream)
+  })
+
+  it('should handle empty stream', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.close()
+      },
+    })
+
+    const iterable = streamToAsyncIterable(stream)
+    const results: unknown[] = []
+
+    for await (const value of iterable) {
+      results.push(value)
+    }
+
+    expect(results).toEqual([])
+  })
+})

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "noEmit": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "paths": {
+      "src": ["./src"]
+    }
+  },
+  "exclude": ["./service.ts", "src/fetch/node.ts"]
+}