@bigmistqke/rpc 0.1.0

package/test/fetch.test.ts

@@ -0,0 +1,310 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { expose, rpc, isFetchRequest, Payload } from '../src/fetch/index'
+
+// Store original fetch
+const originalFetch = globalThis.fetch
+
+describe('isFetchRequest', () => {
+  it('should return true for requests with RPC header', () => {
+    const request = new Request('http://example.com', {
+      headers: { RPC_RR_PROXY: 'true' },
+    })
+    expect(isFetchRequest({ request })).toBe(true)
+  })
+
+  it('should return false for requests without RPC header', () => {
+    const request = new Request('http://example.com')
+    expect(isFetchRequest({ request })).toBe(false)
+  })
+})
+
+describe('Payload', () => {
+  describe('validate', () => {
+    it('should validate correct payloads', () => {
+      expect(Payload.validate({ topics: ['method'], args: [] })).toBe(true)
+      expect(Payload.validate({ topics: ['a', 'b'], args: [1, 'test'] })).toBe(true)
+    })
+
+    it('should reject invalid payloads', () => {
+      expect(Payload.validate({})).toBe(false)
+      expect(Payload.validate({ topics: 'not-array', args: [] })).toBe(false)
+      expect(Payload.validate({ topics: [], args: 'not-array' })).toBe(false)
+    })
+  })
+
+  describe('create', () => {
+    it('should create valid payloads', () => {
+      const payload = Payload.create(['test', 'method'], [1, 2])
+      expect(payload).toEqual({ topics: ['test', 'method'], args: [1, 2] })
+    })
+  })
+})
+
+describe('expose', () => {
+  it('should handle valid RPC requests', async () => {
+    const methods = {
+      greet: (name: string) => `Hello, ${name}!`,
+    }
+
+    const handler = expose(methods)
+    const request = new Request('http://example.com/greet', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['greet'], args: ['World'] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(200)
+    const body = await response.json()
+    expect(body).toEqual({ payload: 'Hello, World!' })
+  })
+
+  it('should handle nested method calls', async () => {
+    const methods = {
+      math: {
+        add: (a: number, b: number) => a + b,
+      },
+    }
+
+    const handler = expose(methods)
+    const request = new Request('http://example.com/math/add', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['math', 'add'], args: [5, 3] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(200)
+    const body = await response.json()
+    expect(body).toEqual({ payload: 8 })
+  })
+
+  it('should handle async methods', async () => {
+    const methods = {
+      asyncMethod: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10))
+        return 'async result'
+      },
+    }
+
+    const handler = expose(methods)
+    const request = new Request('http://example.com', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['asyncMethod'], args: [] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(200)
+    const body = await response.json()
+    expect(body).toEqual({ payload: 'async result' })
+  })
+
+  it('should return 500 for invalid payload shape', async () => {
+    const methods = { test: () => 'ok' }
+    const handler = expose(methods)
+
+    const request = new Request('http://example.com', {
+      method: 'POST',
+      body: JSON.stringify({ invalid: 'data' }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(500)
+    expect(response.statusText).toBe('Incorrect shape')
+  })
+
+  it('should return 500 when method throws string error', async () => {
+    const methods = {
+      failing: () => {
+        throw 'String error message'
+      },
+    }
+
+    const handler = expose(methods)
+    const request = new Request('http://example.com', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['failing'], args: [] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(500)
+    expect(response.statusText).toBe('String error message')
+  })
+
+  it('should return 500 when method throws Error object', async () => {
+    const methods = {
+      failing: () => {
+        throw new Error('Error object message')
+      },
+    }
+
+    const handler = expose(methods)
+    const request = new Request('http://example.com', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['failing'], args: [] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(500)
+    expect(response.statusText).toBe('Error object message')
+  })
+
+  it('should return 500 with undefined statusText for non-string/non-Error throws', async () => {
+    const methods = {
+      failing: () => {
+        throw { custom: 'error' }
+      },
+    }
+
+    const handler = expose(methods)
+    const request = new Request('http://example.com', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['failing'], args: [] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(500)
+  })
+
+  it('should return 500 when method does not exist', async () => {
+    const methods = {}
+    const handler = expose(methods)
+
+    const request = new Request('http://example.com', {
+      method: 'POST',
+      body: JSON.stringify({ topics: ['nonexistent'], args: [] }),
+    })
+
+    const response = await handler({ request })
+
+    expect(response.status).toBe(500)
+  })
+})
+
+describe('rpc', () => {
+  beforeEach(() => {
+    globalThis.fetch = vi.fn()
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('should create proxy that makes POST requests', async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValue(
+      new Response(JSON.stringify({ payload: 'result' }), { status: 200 }),
+    )
+
+    const proxy = rpc<{ method: () => string }>('http://api.example.com')
+    const result = await proxy.method()
+
+    expect(result).toBe('result')
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'POST',
+      }),
+    )
+  })
+
+  it('should construct URL from topics', async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValue(
+      new Response(JSON.stringify({ payload: 'ok' }), { status: 200 }),
+    )
+
+    const proxy = rpc<{ user: { profile: { get: () => string } } }>('http://api.example.com')
+    await proxy.user.profile.get()
+
+    const calledRequest = vi.mocked(globalThis.fetch).mock.calls[0][0] as Request
+    expect(calledRequest.url).toBe('http://api.example.com/user/profile/get')
+  })
+
+  it('should include RPC header in requests', async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValue(
+      new Response(JSON.stringify({ payload: 'ok' }), { status: 200 }),
+    )
+
+    const proxy = rpc<{ test: () => void }>('http://api.example.com')
+    await proxy.test()
+
+    const calledRequest = vi.mocked(globalThis.fetch).mock.calls[0][0] as Request
+    expect(calledRequest.headers.get('RPC_RR_PROXY')).toBe('true')
+  })
+
+  it('should send topics and args in request body', async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValue(
+      new Response(JSON.stringify({ payload: 'ok' }), { status: 200 }),
+    )
+
+    const proxy = rpc<{ add: (a: number, b: number) => number }>('http://api.example.com')
+    await proxy.add(1, 2)
+
+    const calledRequest = vi.mocked(globalThis.fetch).mock.calls[0][0] as Request
+    const body = await calledRequest.json()
+    expect(body).toEqual({ topics: ['add'], args: [1, 2] })
+  })
+
+  it('should throw when response status is not 200', async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValue(
+      new Response(null, { status: 500, statusText: 'Internal Server Error' }),
+    )
+
+    const proxy = rpc<{ method: () => void }>('http://api.example.com')
+
+    await expect(proxy.method()).rejects.toBe('Internal Server Error')
+  })
+
+  // Note: The source code attempts to use GET when topics is empty, but still includes
+  // a body which causes an error. This test documents that behavior.
+  it('should throw when calling with empty topics due to GET with body', async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValue(
+      new Response(JSON.stringify({ payload: 'ok' }), { status: 200 }),
+    )
+
+    const proxy = rpc<() => string>('http://api.example.com')
+    // Direct call with no topics - this throws because GET can't have a body
+    await expect((proxy as any)()).rejects.toThrow('Request with GET/HEAD method cannot have body')
+  })
+})
+
+describe('expose + rpc integration', () => {
+  beforeEach(() => {
+    // Create an in-memory mock that connects expose and rpc
+    const methods = {
+      greet: (name: string) => `Hello, ${name}!`,
+      math: {
+        add: (a: number, b: number) => a + b,
+        subtract: (a: number, b: number) => a - b,
+      },
+    }
+
+    const handler = expose(methods)
+
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      const request = input as Request
+      return handler({ request })
+    })
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('should work end-to-end', async () => {
+    const proxy = rpc<{
+      greet: (name: string) => string
+      math: {
+        add: (a: number, b: number) => number
+        subtract: (a: number, b: number) => number
+      }
+    }>('http://test.local')
+
+    expect(await proxy.greet('Test')).toBe('Hello, Test!')
+    expect(await proxy.math.add(10, 5)).toBe(15)
+    expect(await proxy.math.subtract(10, 5)).toBe(5)
+  })
+})

package/test/message-protocol.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest'
+import {
+  RequestShape,
+  ResponseShape,
+  ErrorShape,
+  RPCPayloadShape,
+  $MESSENGER_REQUEST,
+  $MESSENGER_RESPONSE,
+  $MESSENGER_ERROR,
+  $MESSENGER_RPC_REQUEST,
+} from '../src/message-protocol'
+
+describe('RequestShape', () => {
+  describe('validate', () => {
+    it('should validate correct request objects', () => {
+      expect(RequestShape.validate({ [$MESSENGER_REQUEST]: 0, payload: 'test' })).toBe(true)
+      expect(RequestShape.validate({ [$MESSENGER_REQUEST]: 123, payload: { data: true } })).toBe(
+        true,
+      )
+      expect(RequestShape.validate({ [$MESSENGER_REQUEST]: 999, payload: null })).toBe(true)
+    })
+
+    it('should reject invalid request objects', () => {
+      expect(RequestShape.validate({})).toBe(false)
+      expect(RequestShape.validate({ [$MESSENGER_REQUEST]: 'not a number', payload: 'test' })).toBe(
+        false,
+      )
+      expect(RequestShape.validate({ payload: 'test' })).toBe(false)
+      expect(RequestShape.validate(null)).toBe(false)
+      expect(RequestShape.validate(undefined)).toBe(false)
+    })
+  })
+
+  describe('create', () => {
+    it('should create valid request objects', () => {
+      const request = RequestShape.create(42, { method: 'test' })
+      expect(request).toEqual({
+        [$MESSENGER_REQUEST]: 42,
+        payload: { method: 'test' },
+      })
+      expect(RequestShape.validate(request)).toBe(true)
+    })
+  })
+})
+
+describe('ResponseShape', () => {
+  describe('validate', () => {
+    it('should validate correct response objects', () => {
+      expect(ResponseShape.validate({ [$MESSENGER_RESPONSE]: 0, payload: 'result' })).toBe(true)
+      expect(ResponseShape.validate({ [$MESSENGER_RESPONSE]: 123, payload: { data: true } })).toBe(
+        true,
+      )
+    })
+
+    it('should reject invalid response objects', () => {
+      expect(ResponseShape.validate({})).toBe(false)
+      expect(
+        ResponseShape.validate({ [$MESSENGER_RESPONSE]: 'not a number', payload: 'test' }),
+      ).toBe(false)
+      expect(ResponseShape.validate({ payload: 'test' })).toBe(false)
+    })
+  })
+
+  describe('create', () => {
+    it('should create valid response objects from request', () => {
+      const request = { [$MESSENGER_REQUEST]: 42, payload: {} }
+      const response = ResponseShape.create(request, 'result')
+      expect(response).toEqual({
+        [$MESSENGER_RESPONSE]: 42,
+        payload: 'result',
+      })
+      expect(ResponseShape.validate(response)).toBe(true)
+    })
+  })
+})
+
+describe('ErrorShape', () => {
+  describe('validate', () => {
+    it('should validate correct error objects', () => {
+      expect(ErrorShape.validate({ [$MESSENGER_ERROR]: 0, error: 'error message' })).toBe(true)
+      expect(ErrorShape.validate({ [$MESSENGER_ERROR]: 123, error: { message: 'test' } })).toBe(
+        true,
+      )
+    })
+
+    it('should reject invalid error objects', () => {
+      expect(ErrorShape.validate({})).toBe(false)
+      expect(ErrorShape.validate({ [$MESSENGER_ERROR]: 'not a number', error: 'test' })).toBe(false)
+      expect(ErrorShape.validate({ error: 'test' })).toBe(false)
+    })
+  })
+
+  describe('create', () => {
+    it('should create valid error objects from request', () => {
+      const request = { [$MESSENGER_REQUEST]: 42, payload: {} }
+      const error = ErrorShape.create(request, 'Something went wrong')
+      expect(error).toEqual({
+        [$MESSENGER_ERROR]: 42,
+        error: 'Something went wrong',
+      })
+      expect(ErrorShape.validate(error)).toBe(true)
+    })
+  })
+})
+
+describe('RPCPayloadShape', () => {
+  describe('validate', () => {
+    it('should validate correct RPC payload objects', () => {
+      expect(
+        RPCPayloadShape.validate({
+          [$MESSENGER_RPC_REQUEST]: true,
+          topics: ['method'],
+          args: [],
+        }),
+      ).toBe(true)
+      expect(
+        RPCPayloadShape.validate({
+          [$MESSENGER_RPC_REQUEST]: true,
+          topics: ['user', 'profile', 'get'],
+          args: [1, 'test'],
+        }),
+      ).toBe(true)
+    })
+
+    it('should reject invalid RPC payload objects', () => {
+      expect(RPCPayloadShape.validate({})).toBe(false)
+      expect(RPCPayloadShape.validate({ [$MESSENGER_RPC_REQUEST]: true })).toBe(false)
+      expect(
+        RPCPayloadShape.validate({
+          [$MESSENGER_RPC_REQUEST]: true,
+          topics: 'not an array',
+          args: [],
+        }),
+      ).toBe(false)
+      expect(
+        RPCPayloadShape.validate({
+          [$MESSENGER_RPC_REQUEST]: 'not a boolean',
+          topics: [],
+          args: [],
+        }),
+      ).toBe(false)
+    })
+  })
+
+  describe('create', () => {
+    it('should create valid RPC payload objects', () => {
+      const payload = RPCPayloadShape.create(['user', 'get'], [42])
+      expect(payload).toEqual({
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: ['user', 'get'],
+        args: [42],
+      })
+      expect(RPCPayloadShape.validate(payload)).toBe(true)
+    })
+
+    it('should handle empty topics and args', () => {
+      const payload = RPCPayloadShape.create([], [])
+      expect(payload).toEqual({
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: [],
+        args: [],
+      })
+      expect(RPCPayloadShape.validate(payload)).toBe(true)
+    })
+  })
+})