@push-rpc/next 2.0.0-beta.1

package/tests/subscriptions.ts

@@ -0,0 +1,442 @@
+import {assert} from "chai"
+import {createTestClient, startTestServer, testClient, testServer} from "./testUtils.js"
+import {adelay} from "../src/utils/promises.js"
+import {CallOptions, RpcErrors} from "../src/index.js"
+
+describe("Subscriptions", () => {
+  it("subscribe delivers data", async () => {
+    const item = {r: "1"}
+
+    const services = await startTestServer({
+      test: {
+        item: async () => item,
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    let receivedItem
+
+    await client.test.item.subscribe(() => {
+      receivedItem = item
+    })
+
+    await adelay(50)
+    assert.deepEqual(receivedItem, item)
+  })
+
+  it("error in supplier breaks subscribe", async () => {
+    const services = await startTestServer({
+      item: async () => {
+        throw new Error("AA")
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    try {
+      await client.item.subscribe(() => {})
+      assert.fail("Error expected")
+    } catch (e: any) {
+      assert.equal(e.message, "AA")
+    }
+  })
+
+  it("exception during subscribe do not create subscription", async () => {
+    const services = {
+      item: async () => {
+        throw new Error()
+      },
+    }
+
+    await startTestServer(services)
+
+    const remote = await createTestClient<typeof services>()
+
+    remote.item
+      .subscribe(() => {})
+      .catch((e: any) => {
+        // ignored
+      })
+
+    // pause the socket so that the server doesn't get the unsubscribe message
+    await adelay(20)
+
+    assert.equal(0, testServer?._allSubscriptions().length)
+  })
+
+  it("2nd subscribe", async () => {
+    const item = {r: "1"}
+
+    const services = await startTestServer({
+      test: {
+        item: async () => item,
+      },
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    let item1
+    await remote.test.item.subscribe((item) => {
+      item1 = item
+    })
+
+    await adelay(50)
+    assert.deepEqual(item1, item)
+
+    let item2
+    await remote.test.item.subscribe((item) => {
+      item2 = item
+    })
+
+    await adelay(50)
+    assert.deepEqual(item2, item)
+
+    // trigger sends item
+    item.r = "2"
+    services.test.item.trigger()
+    await adelay(50)
+    assert.deepEqual(item1, item)
+    assert.deepEqual(item2, item)
+
+    // a single subscription present on server
+    assert.equal(testServer?._allSubscriptions().length, 1)
+    assert.equal(testServer?._allSubscriptions()[0][0], "test/item")
+  })
+
+  it("concurrent subscribe cache", async () => {
+    const item = {r: "1"}
+    let supplied = 0
+
+    const server = {
+      test: {
+        item: async () => {
+          await adelay(1)
+          supplied++
+          return item
+        },
+      },
+    }
+
+    await startTestServer(server)
+
+    const client = await createTestClient<typeof server>()
+
+    let item1
+    client.test.item.subscribe((item) => {
+      item1 = item
+    })
+
+    let item2
+    client.test.item.subscribe((item) => {
+      item2 = item
+    })
+
+    await adelay(50)
+    assert.deepEqual(item1, item)
+    assert.deepEqual(item2, item)
+
+    assert.equal(supplied, 1)
+  })
+
+  it("subscribe use client cached value", async () => {
+    const item = {r: "1"}
+
+    const server = {
+      test: {
+        item: async () => item,
+      },
+    }
+
+    await startTestServer(server)
+
+    const client = await createTestClient<typeof server>()
+
+    let item1
+    await client.test.item.subscribe((item) => {
+      item1 = item
+    })
+
+    await adelay(50)
+    assert.deepEqual(item1, item)
+
+    item.r = "2"
+
+    let item2
+    client.test.item.subscribe((item) => {
+      item2 = item
+    })
+
+    // cached version should be delivered
+    assert.deepEqual(item2, {r: "1"})
+
+    await adelay(50)
+
+    // and a new version after some time
+    assert.deepEqual(item2, item)
+  })
+
+  it("unsubscribe topics on disconnect", async () => {
+    const item = {r: "1"}
+
+    const server = {
+      testUnsub: {
+        item: async () => item,
+      },
+    }
+
+    await startTestServer(server)
+
+    const remote = await createTestClient<typeof server>()
+
+    await remote.testUnsub.item.subscribe(() => {})
+
+    assert.equal(1, testServer?._allSubscriptions().length)
+
+    await testClient!.close()
+
+    await new Promise((r) => setTimeout(r, 50))
+
+    // client's subscriptions are not removed intentionally not to lose existing handlers
+    assert.equal(testClient?._allSubscriptions().length, 1)
+
+    assert.equal(0, testServer?._allSubscriptions().length)
+  })
+
+  it("resubscribe on reconnect", async () => {
+    const item = {r: "1"}
+
+    const services = await startTestServer({
+      test: {
+        item: async () => item,
+      },
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    let receivedItem
+
+    await remote.test.item.subscribe((item) => {
+      receivedItem = item
+    })
+
+    // first notification right after subscription
+    await adelay(20)
+    assert.deepEqual(receivedItem, item)
+
+    // trigger sends item
+    item.r = "2"
+    services.test.item.trigger()
+    await adelay(20)
+    assert.deepEqual(receivedItem, item)
+
+    // disconnect & resubscribe
+    testClient?._webSocket()?.close()
+    await adelay(50)
+
+    // session should be re-subscribed, trigger should continue to send items
+    item.r = "3"
+    services.test.item.trigger()
+    await adelay(20)
+    assert.deepEqual(receivedItem, item)
+  })
+
+  it("double subscribe leaves session referenced on unsubscribe", async () => {
+    const services = await startTestServer({
+      item: async () => 1,
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    const sub1 = () => {}
+    const sub2 = () => {}
+
+    await remote.item.subscribe(sub1)
+    await adelay(20)
+
+    assert.equal(1, testServer?._allSubscriptions().length)
+    assert.equal(1, testClient?._allSubscriptions().length)
+
+    await remote.item.subscribe(sub2)
+    await adelay(20)
+
+    assert.equal(1, testServer?._allSubscriptions().length)
+    assert.equal(2, testClient?._allSubscriptions().length)
+
+    await remote.item.unsubscribe(sub1)
+    await adelay(100)
+    assert.equal(1, testServer?._allSubscriptions().length)
+    assert.equal(1, testClient?._allSubscriptions().length)
+
+    await remote.item.unsubscribe(sub2)
+    await adelay(100)
+    assert.equal(0, testServer?._allSubscriptions().length)
+    assert.equal(0, testClient?._allSubscriptions().length)
+  })
+
+  it("double subscribe single consumer", async () => {
+    const services = await startTestServer({
+      item: async () => 1,
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    const sub = () => {}
+
+    await remote.item.subscribe(sub)
+    await adelay(20)
+    assert.equal(1, testServer?._allSubscriptions().length)
+
+    await remote.item.subscribe(sub)
+    await adelay(20)
+    assert.equal(1, testServer?._allSubscriptions().length)
+
+    await remote.item.unsubscribe(sub)
+    await adelay(20)
+    assert.equal(1, testServer?._allSubscriptions().length)
+
+    await remote.item.unsubscribe(sub)
+    await adelay(20)
+    assert.equal(0, testServer?._allSubscriptions().length)
+  })
+
+  it("double subscribe leaves session referenced on disconnect", async () => {
+    const services = await startTestServer({
+      item: async () => 1,
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    const sub1 = () => {}
+    const sub2 = () => {}
+
+    await remote.item.subscribe(sub1)
+    await adelay(20)
+    assert.equal(1, testServer?._allSubscriptions().length)
+
+    await remote.item.subscribe(sub2)
+    await adelay(20)
+    assert.equal(1, testServer?._allSubscriptions().length)
+
+    await remote.item.unsubscribe(sub1)
+    await adelay(100)
+
+    await testClient?.close()
+    await adelay(100)
+
+    assert.equal(0, testServer?._allSubscriptions().length)
+  })
+
+  it("double subscribe unsubscribe bug", async () => {
+    let delivered = null
+
+    const services = await startTestServer({
+      test: {
+        item: async () => "ok-" + Date.now(),
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const sub1 = (r: string) => {
+      delivered = r
+    }
+
+    const sub2 = () => {}
+
+    await client.test.item.subscribe(sub1)
+
+    await client.test.item.subscribe(sub2)
+
+    assert.isOk(delivered)
+    delivered = null
+
+    await client.test.item.unsubscribe(sub2)
+
+    services.test.item.trigger()
+
+    await adelay(200)
+
+    assert.isOk(delivered)
+    delivered = null
+  })
+
+  it.skip("unsubscribe before supply bug", async () => {
+    const services = await startTestServer({
+      item: async () => {
+        await adelay(20)
+        return 1
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const sub = () => {}
+    client.item.subscribe(sub)
+
+    await adelay(10)
+
+    client.item.unsubscribe(sub)
+
+    await adelay(20)
+
+    assert.equal(0, testClient!._allSubscriptions().length)
+    assert.equal(0, testServer!._allSubscriptions().length)
+  })
+
+  it("skip unchanged data", async () => {
+    const item = {r: "1"}
+
+    const services = await startTestServer({
+      test: {
+        item: async () => item,
+      },
+    })
+
+    services.test.item.throttle({
+      timeout: 0,
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    let receivedItem
+
+    await client.test.item.subscribe(() => {
+      receivedItem = item
+    })
+
+    await adelay(20)
+    assert.deepEqual(receivedItem, item)
+    receivedItem = null
+
+    services.test.item.trigger()
+    await adelay(20)
+    assert.isNotOk(receivedItem)
+  })
+
+  it("per-subscribe timeout", async () => {
+    const callTimeout = 200
+
+    const services = await startTestServer({
+      test: {
+        async longOp() {
+          await adelay(2 * callTimeout)
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>({
+      callTimeout: 4 * callTimeout,
+    })
+
+    try {
+      await client.test.longOp.subscribe(() => {}, new CallOptions({timeout: callTimeout}))
+      assert.fail()
+    } catch (e: any) {
+      assert.equal(e.code, RpcErrors.Timeout)
+    }
+
+    assert.equal(0, testClient!._allSubscriptions().length)
+    assert.equal(0, testServer!._allSubscriptions().length)
+  }).timeout(5000)
+})

package/tests/testUtils.ts

@@ -0,0 +1,52 @@
+import {
+  consumeServices,
+  ConsumeServicesOptions,
+  publishServices,
+  PublishServicesOptions,
+  RpcClient,
+  RpcContext,
+  RpcServer,
+  Services,
+  ServicesWithSubscriptions,
+  ServicesWithTriggers,
+} from "../src/index.js"
+
+export const TEST_PORT = 5555
+
+export let testServer: RpcServer | null = null
+
+export async function startTestServer<S extends Services<S>, C extends RpcContext>(
+  local: S,
+  options: Partial<PublishServicesOptions<C>> = {}
+): Promise<ServicesWithTriggers<S>> {
+  const r = await publishServices<S, C>(local, {
+    port: TEST_PORT,
+    path: "/rpc",
+    ...options,
+  })
+  testServer = r.server
+  return r.services
+}
+
+export let testClient: RpcClient | null = null
+
+export async function createTestClient<S extends Services<S>>(
+  options?: Partial<ConsumeServicesOptions>
+): Promise<ServicesWithSubscriptions<S>> {
+  const r = await consumeServices<S>(`http://127.0.0.1:${TEST_PORT}/rpc`, options)
+  testClient = r.client
+  return r.remote
+}
+
+afterEach(async function () {
+  this.timeout(4000)
+
+  if (testClient) {
+    await testClient.close()
+    testClient = null
+  }
+  if (testServer) {
+    await testServer.close()
+    testServer = null
+  }
+})

package/tests/triggers.ts

@@ -0,0 +1,138 @@
+import {createTestClient, startTestServer} from "./testUtils.js"
+import {adelay} from "../src/utils/promises.js"
+import {assert} from "chai"
+import {groupReducer} from "../src/utils/throttle.js"
+
+describe("Subscription triggers", () => {
+  it("trigger filter", async () => {
+    interface Item {
+      key: string
+      updated: number
+    }
+
+    const services = await startTestServer({
+      test: {
+        async item({key}: {key: string}): Promise<{key: string; updated: number}> {
+          return {key, updated: Date.now()}
+        },
+      },
+    })
+
+    services.test.item.throttle({
+      timeout: 0,
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    let item1
+    let item2
+
+    const sub1 = (item: Item) => (item1 = item)
+    const sub2 = (item: Item) => (item2 = item)
+
+    await remote.test.item.subscribe(sub1, {key: "1"})
+    await remote.test.item.subscribe(sub2, {key: "2"})
+
+    // first notificaiton right after subscription, clear items
+    await adelay(20)
+
+    // trigger sends 1st item, but not second
+    item1 = null
+    item2 = null
+
+    services.test.item.trigger({key: "1"})
+    await adelay(20)
+    assert.equal(item1!.key, "1")
+    assert.isNull(item2)
+
+    // null trigger sends all items
+    item1 = null
+    item2 = null
+
+    services.test.item.trigger()
+    await adelay(20)
+    assert.deepEqual(item1!.key, "1")
+    assert.deepEqual(item2!.key, "2")
+  })
+
+  it("trigger throttling", async () => {
+    const throttleTimeout = 400
+
+    const services = await startTestServer({
+      test: {
+        item: async () => "result",
+      },
+    })
+
+    services.test.item.throttle({
+      timeout: throttleTimeout,
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    let count = 0
+    let item = null
+
+    await remote.test.item.subscribe((i) => {
+      count++
+      item = i
+    })
+
+    await adelay(50)
+    assert.equal(count, 1)
+    assert.equal(item, "result")
+
+    services.test.item.trigger(undefined, "1st")
+    services.test.item.trigger(undefined, "2nd") // throttled
+    await adelay(50)
+    assert.equal(count, 2)
+    assert.equal(item, "1st")
+
+    services.test.item.trigger(undefined, "3rd") // throttled
+    services.test.item.trigger(undefined, "4th") // delivered on trailing edge
+
+    await adelay(50)
+    assert.equal(count, 2)
+
+    await adelay(throttleTimeout + 50)
+    assert.equal(count, 3)
+    assert.equal(item, "4th")
+  })
+
+  it("throttling reducer", async () => {
+    const throttleTimeout = 400
+
+    const services = await startTestServer({
+      test: {
+        item: async () => [] as number[],
+      },
+    })
+
+    services.test.item.throttle({
+      timeout: throttleTimeout,
+      reducer: groupReducer,
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    let item = null
+
+    await remote.test.item.subscribe((i) => {
+      console.log(i)
+      item = i
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    await adelay(50)
+    assert.deepEqual(item, [])
+
+    services.test.item.trigger(undefined, [1])
+    services.test.item.trigger(undefined, [2]) // throttled
+    services.test.item.trigger(undefined, [3]) // throttled
+    await adelay(50)
+    assert.deepEqual(item, [1])
+
+    await new Promise((resolve) => setTimeout(resolve, throttleTimeout))
+    assert.deepEqual(item, [2, 3]) // trailing edge
+  })
+})

package/tsconfig.cjs.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "CommonJS",
+    "lib": [
+      "es2020"
+    ],
+    "declaration": true,
+    "sourceMap": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "NodeNext",
+    "lib": [
+      "es2020"
+    ],
+    "declaration": true,
+    "sourceMap": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "ts-node": {
+    "esm": true,
+    "moduleTypes": {
+      "*": "esm"
+    }
+  }
+}