@bigmistqke/rpc 0.1.3 → 0.1.4

package/test/messenger.test.ts

@@ -1,11 +1,12 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { expose, rpc, createResponder } from '../src/messenger'
+import { describe, expect, it, vi } from 'vitest'
+import { createResponder, expose, handle, rpc } from '../src/messenger'
 import {
+  $MESSENGER_ERROR,
+  $MESSENGER_HANDLE,
   $MESSENGER_REQUEST,
   $MESSENGER_RESPONSE,
-  $MESSENGER_ERROR,
   $MESSENGER_RPC_REQUEST,
-} from '../src/message-protocol'
+} from '../src/protocol'
 
 // Helper to flush pending promises
 const flushPromises = () => new Promise(resolve => setTimeout(resolve, 0))
@@ -121,14 +122,17 @@ describe('createResponder', () => {
 })
 
 describe('expose', () => {
-  it('should handle RPC requests and call methods', async () => {
+  it('should handle RPC requests directly', async () => {
     const port = createMockMessagePort()
-    const methods = {
-      greet: (name: string) => `Hello, ${name}!`,
-    }
 
-    expose(methods, { to: port })
+    expose(
+      {
+        greet: (name: string) => `Hello, ${name}!`,
+      },
+      { to: port },
+    )
 
+    // Send RPC request directly (no init needed)
     port._emit({
       [$MESSENGER_REQUEST]: 1,
       payload: {
@@ -151,15 +155,17 @@ describe('expose', () => {
 
   it('should handle nested method calls', async () => {
     const port = createMockMessagePort()
-    const methods = {
-      user: {
-        profile: {
-          getName: () => 'John Doe',
+
+    expose(
+      {
+        user: {
+          profile: {
+            getName: () => 'John Doe',
+          },
         },
       },
-    }
-
-    expose(methods, { to: port })
+      { to: port },
+    )
 
     port._emit({
       [$MESSENGER_REQUEST]: 1,
@@ -181,31 +187,167 @@ describe('expose', () => {
     )
   })
 
-  it('should ignore non-RPC payloads', () => {
+  it('should handle async methods', async () => {
     const port = createMockMessagePort()
-    const methods = {
-      test: vi.fn(),
-    }
 
-    expose(methods, { to: port })
+    expose(
+      {
+        asyncMethod: async () => {
+          await new Promise(resolve => setTimeout(resolve, 10))
+          return 'async result'
+        },
+      },
+      { to: port },
+    )
 
     port._emit({
       [$MESSENGER_REQUEST]: 1,
-      payload: { notRpc: true },
+      payload: {
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: ['asyncMethod'],
+        args: [],
+      },
     })
 
-    expect(methods.test).not.toHaveBeenCalled()
+    await new Promise(resolve => setTimeout(resolve, 20))
+
+    expect(port.postMessage).toHaveBeenCalledWith(
+      {
+        [$MESSENGER_RESPONSE]: 1,
+        payload: 'async result',
+      },
+      [],
+    )
+  })
+
+  it('should return handle response when method returns handle()', async () => {
+    const port = createMockMessagePort()
+
+    expose(
+      {
+        init: () =>
+          handle({
+            getValue: () => 42,
+          }),
+      },
+      { to: port },
+    )
+
+    port._emit({
+      [$MESSENGER_REQUEST]: 1,
+      payload: {
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: ['init'],
+        args: [],
+      },
+    })
+
+    await flushPromises()
+
+    // Should return a handle response with namespace ID
+    expect(port.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        [$MESSENGER_RESPONSE]: 1,
+        payload: expect.objectContaining({
+          [$MESSENGER_HANDLE]: expect.stringContaining('__rpc_handle_'),
+        }),
+      }),
+      [],
+    )
+  })
+
+  it('should handle namespaced RPC calls from handle()', async () => {
+    const port = createMockMessagePort()
+    const getValue = vi.fn(() => 42)
+
+    expose(
+      {
+        init: () =>
+          handle({
+            getValue,
+          }),
+      },
+      { to: port },
+    )
+
+    // First call init to get namespace ID
+    port._emit({
+      [$MESSENGER_REQUEST]: 1,
+      payload: {
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: ['init'],
+        args: [],
+      },
+    })
+
+    await flushPromises()
+
+    // Extract namespace ID from response
+    const initResponse = port.postMessage.mock.calls[0]![0]
+    const namespaceId = initResponse.payload[$MESSENGER_HANDLE]
+
+    // Now call method on the handle
+    port._emit({
+      [$MESSENGER_REQUEST]: 2,
+      payload: {
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: [namespaceId, 'getValue'],
+        args: [],
+      },
+    })
+
+    await flushPromises()
+
+    expect(getValue).toHaveBeenCalled()
+    expect(port.postMessage).toHaveBeenLastCalledWith(
+      {
+        [$MESSENGER_RESPONSE]: 2,
+        payload: 42,
+      },
+      [],
+    )
+  })
+
+  it('should handle errors in RPC methods', async () => {
+    const port = createMockMessagePort()
+
+    expose(
+      {
+        failingMethod: () => {
+          throw new Error('test error')
+        },
+      },
+      { to: port },
+    )
+
+    port._emit({
+      [$MESSENGER_REQUEST]: 1,
+      payload: {
+        [$MESSENGER_RPC_REQUEST]: true,
+        topics: ['failingMethod'],
+        args: [],
+      },
+    })
+
+    await flushPromises()
+
+    expect(port.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        [$MESSENGER_ERROR]: 1,
+      }),
+      undefined,
+    )
   })
 })
 
 describe('rpc', () => {
-  it('should create a proxy that sends RPC requests', async () => {
+  it('should create a synchronous proxy that sends RPC requests', async () => {
     const { port1, port2 } = createMockMessageChannel()
 
     // Set up responder on port2
     expose({ add: (a: number, b: number) => a + b }, { to: port2 })
 
-    // Create RPC proxy on port1
+    // Create RPC proxy on port1 (now synchronous)
     const proxy = rpc<{ add: (a: number, b: number) => number }>(port1)
 
     const result = await proxy.add(2, 3)
@@ -244,11 +386,7 @@ describe('rpc', () => {
 
     const proxy = rpc<{ failingMethod: () => void }>(port1)
 
-    // Note: Currently, errors in expose() are caught and logged but not rethrown,
-    // so the response is undefined rather than an error rejection.
-    // This is a quirk of the current implementation.
-    const result = await proxy.failingMethod()
-    expect(result).toBeUndefined()
+    await expect(proxy.failingMethod()).rejects.toThrow()
   })
 
   it('should handle multiple concurrent requests', async () => {
@@ -276,6 +414,85 @@ describe('rpc', () => {
     expect(result2).toBe('second')
     expect(result3).toBe('third')
   })
+
+  it('should create sub-proxy when method returns handle()', async () => {
+    const { port1, port2 } = createMockMessageChannel()
+
+    expose(
+      {
+        init: (multiplier: number) =>
+          handle({
+            multiply: (a: number) => a * multiplier,
+          }),
+      },
+      { to: port2 },
+    )
+
+    const proxy = rpc<{
+      init: (multiplier: number) => { multiply: (a: number) => number }
+    }>(port1)
+
+    // Call init to get sub-proxy
+    const calculator = await proxy.init(10)
+
+    // Call method on sub-proxy
+    const result = await calculator.multiply(5)
+    expect(result).toBe(50)
+  })
+
+  it('should handle async methods that return handle()', async () => {
+    const { port1, port2 } = createMockMessageChannel()
+
+    expose(
+      {
+        asyncInit: async (config: { prefix: string }) => {
+          await new Promise(resolve => setTimeout(resolve, 10))
+          return handle({
+            greet: (name: string) => `${config.prefix} ${name}!`,
+          })
+        },
+      },
+      { to: port2 },
+    )
+
+    const proxy = rpc<{
+      asyncInit: (config: { prefix: string }) => Promise<{ greet: (name: string) => string }>
+    }>(port1)
+
+    const greeter = await proxy.asyncInit({ prefix: 'Hello,' })
+    const result = await greeter.greet('World')
+    expect(result).toBe('Hello, World!')
+  })
+
+  it('should handle nested handle() calls', async () => {
+    const { port1, port2 } = createMockMessageChannel()
+
+    expose(
+      {
+        createOuter: () =>
+          handle({
+            createInner: () =>
+              handle({
+                getValue: () => 'nested value',
+              }),
+          }),
+      },
+      { to: port2 },
+    )
+
+    const proxy = rpc<{
+      createOuter: () => {
+        createInner: () => {
+          getValue: () => string
+        }
+      }
+    }>(port1)
+
+    const outer = await proxy.createOuter()
+    const inner = await outer.createInner()
+    const result = await inner.getValue()
+    expect(result).toBe('nested value')
+  })
 })
 
 describe('Window vs Worker handling', () => {
@@ -288,6 +505,7 @@ describe('Window vs Worker handling', () => {
 
     expose({ test: () => 'ok' }, { to: windowLike as any })
 
+    // Send RPC
     windowLike.addEventListener.mock.calls[0]![1]({
       data: {
         [$MESSENGER_REQUEST]: 1,
@@ -302,11 +520,7 @@ describe('Window vs Worker handling', () => {
     await flushPromises()
 
     // Window-style postMessage should include '*' as second argument
-    expect(windowLike.postMessage).toHaveBeenCalledWith(
-      expect.any(Object),
-      '*',
-      [],
-    )
+    expect(windowLike.postMessage).toHaveBeenCalledWith(expect.any(Object), '*', [])
   })
 
   it('should not use targetOrigin for Worker-like objects', async () => {

package/test/{message-protocol.test.ts → protocol.test.ts}

@@ -1,14 +1,14 @@
-import { describe, it, expect } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import {
-  RequestShape,
-  ResponseShape,
-  ErrorShape,
-  RPCPayloadShape,
+  $MESSENGER_ERROR,
   $MESSENGER_REQUEST,
   $MESSENGER_RESPONSE,
-  $MESSENGER_ERROR,
   $MESSENGER_RPC_REQUEST,
-} from '../src/message-protocol'
+  ErrorShape,
+  RequestShape,
+  ResponseShape,
+  RPCPayloadShape,
+} from '../src/protocol'
 
 describe('RequestShape', () => {
   describe('validate', () => {

package/test/sse.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { expose, rpc, isSSEResponse, Payload } from '../src/server-send-events/index'
-import { $MESSENGER_REQUEST, $MESSENGER_RPC_REQUEST } from '../src/message-protocol'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { $MESSENGER_REQUEST, $MESSENGER_RPC_REQUEST } from '../src/protocol'
+import { expose, isSSEResponse, Payload, rpc } from '../src/server-send-events/index'
 
 // Mock EventSource
 class MockEventSource {

package/test/stream.test.ts

@@ -79,10 +79,7 @@ describe('rpc', () => {
     }
 
     // Set up endpoint 1 - reads from stream1, writes to its output stream
-    const endpoint1 = rpc<{ echo: (msg: string) => string }, typeof methods1>(
-      stream1,
-      methods1,
-    )
+    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)
@@ -233,7 +230,6 @@ describe('rpc', () => {
         enqueue2(decoder.decode(value))
       }
     })()
-
     ;(async () => {
       while (true) {
         const { done, value } = await reader2.read()

package/test/utils.test.ts

@@ -1,11 +1,10 @@
 import { describe, it, expect, vi } from 'vitest'
+import { callMethod, createCommander } from '../src/core'
 import {
   createIdAllocator,
   createIdRegistry,
   createPromiseRegistry,
   defer,
-  createCommander,
-  callMethod,
   createReadableStream,
   streamToAsyncIterable,
   createShape,