@push-rpc/next 2.0.0-beta.1

package/tests/context.ts

@@ -0,0 +1,176 @@
+import {createTestClient, startTestServer} from "./testUtils.js"
+import {assert} from "chai"
+import {adelay} from "../src/utils/promises.js"
+import {RpcContext} from "../src/index.js"
+import {InvocationType, RpcConnectionContext} from "../src/rpc.js"
+
+describe("context", () => {
+  it("available in call", async () => {
+    let ctx: RpcContext | undefined
+
+    const services = await startTestServer({
+      test: {
+        async call(passedCtx?: RpcContext) {
+          ctx = passedCtx
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.call()
+
+    assert.ok(ctx)
+    assert.ok(ctx!.clientId)
+    assert.equal(ctx!.itemName, "test/call")
+    assert.equal(ctx!.invocationType, InvocationType.Call)
+  })
+
+  it("override creation", async () => {
+    let ctx = null
+
+    const services = await startTestServer(
+      {
+        test: {
+          async call(passedCtx?: any) {
+            ctx = passedCtx
+          },
+        },
+      },
+      {
+        async createConnectionContext() {
+          return {clientId: "test", newKey: "bla"}
+        },
+      }
+    )
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.call()
+
+    assert.equal(ctx!.clientId, "test")
+    assert.equal(ctx!.newKey, "bla")
+  })
+
+  it("available in subscribe", async () => {
+    let ctx = null
+
+    const services = await startTestServer({
+      test: {
+        async call(passedCtx?: any) {
+          ctx = passedCtx
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.call.subscribe(() => {})
+
+    assert.ok(ctx)
+    assert.ok(ctx!.clientId)
+    assert.equal(ctx!.invocationType, InvocationType.Subscribe)
+  })
+
+  it("available in trigger", async () => {
+    let ctx = null
+
+    const services = await startTestServer(
+      {
+        test: {
+          async call(passedCtx?: any) {
+            ctx = passedCtx
+          },
+        },
+      },
+      {
+        async createConnectionContext() {
+          return {clientId: "test"}
+        },
+      }
+    )
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.call.subscribe(() => {})
+    assert.equal(ctx!.clientId, "test")
+
+    ctx = null
+    services.test.call.trigger()
+    await adelay(20)
+    assert.equal(ctx!.clientId, "test")
+    assert.equal(ctx!.invocationType, InvocationType.Trigger)
+  })
+
+  it("trigger has a copy", async () => {
+    let ctx = null
+
+    let count = 0
+
+    const services = await startTestServer(
+      {
+        test: {
+          async call(passedCtx?: any) {
+            ctx = passedCtx
+
+            if (!count) {
+              ctx.modified = true
+            }
+
+            count++
+          },
+        },
+      },
+      {
+        async createConnectionContext() {
+          return {clientId: "test"}
+        },
+      }
+    )
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.call.subscribe(() => {})
+    services.test.call.trigger()
+
+    await adelay(20)
+    assert.isNotOk(ctx!.modified)
+  })
+
+  it("modified in middleware", async () => {
+    let ctx = null
+
+    type Ctx = RpcContext & {count: number}
+
+    const services = await startTestServer(
+      {
+        test: {
+          async call(passedCtx?: any) {
+            ctx = passedCtx
+          },
+        },
+      },
+      {
+        async createConnectionContext() {
+          return {clientId: "test", count: 0}
+        },
+        middleware: [
+          (ctx: Ctx, next) => {
+            ctx.count++
+            return next(ctx)
+          },
+        ],
+      }
+    )
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.call.subscribe(() => {})
+    assert.equal(ctx!.count, 1)
+
+    services.test.call.trigger()
+
+    await adelay(20)
+    assert.equal(ctx!.count, 1)
+  })
+})

package/tests/middleware.ts

@@ -0,0 +1,112 @@
+import {assert} from "chai"
+import {Middleware, withMiddlewares} from "../src/index.js"
+import {createTestClient, startTestServer} from "./testUtils.js"
+import {adelay} from "../src/utils/promises.js"
+
+describe("middleware", () => {
+  it("compose override params", async () => {
+    const m1: Middleware<{}> = (ctx, next, param: any) => {
+      return next(param + 1)
+    }
+
+    const m2: Middleware<{}> = (ctx, next, param: any) => {
+      return next(param + 2)
+    }
+
+    const r = await withMiddlewares({}, [m1, m2], async (p, ctx) => p, 0)
+
+    assert.equal(r, 3)
+  })
+
+  it("compose use prev params", async () => {
+    const m1: Middleware<{}> = (ctx, next) => {
+      return next()
+    }
+
+    const r = await withMiddlewares({}, [m1], async (p) => p, 0)
+
+    assert.equal(r, 0)
+  })
+
+  it("local", async () => {
+    let contextValue = null
+
+    const services = await startTestServer(
+      {
+        item: async (ctx?: any) => {
+          contextValue = ctx.value
+        },
+      },
+      {
+        middleware: [
+          (ctx: any, next) => {
+            ctx.value = 1
+            return next()
+          },
+        ],
+      }
+    )
+
+    const remote = await createTestClient<typeof services>()
+    await remote.item()
+    assert.equal(contextValue, 1)
+
+    contextValue = null
+    await remote.item.subscribe(() => {})
+    assert.equal(contextValue, 1)
+
+    contextValue = null
+    services.item.trigger()
+    await adelay(20)
+    assert.equal(contextValue, 1)
+  })
+
+  it("remote", async () => {
+    let mwInvoked = false
+
+    const services = await startTestServer({
+      item: async () => "1",
+    })
+
+    const remote = await createTestClient<typeof services>({
+      middleware: [
+        (ctx, next) => {
+          mwInvoked = true
+          return next()
+        },
+      ],
+    })
+
+    await remote.item()
+    assert.isOk(mwInvoked)
+
+    const sub = () => {}
+
+    mwInvoked = false
+    await remote.item.subscribe(sub)
+    assert.isOk(mwInvoked)
+
+    mwInvoked = false
+    await remote.item.unsubscribe(sub)
+    assert.isOk(mwInvoked)
+  })
+
+  it("remote with rejection", async () => {
+    const services = await startTestServer({
+      async getSomething() {
+        throw new Error("msg")
+      },
+    })
+
+    const client = await createTestClient<typeof services>({
+      middleware: [(ctx, next, params) => next(params)],
+    })
+
+    try {
+      await client.getSomething()
+      assert.fail("Error expected")
+    } catch (e: any) {
+      assert.equal(e.message, "msg")
+    }
+  })
+})

package/tests/misc.ts

@@ -0,0 +1,187 @@
+import {assert} from "chai"
+import {createTestClient, startTestServer, TEST_PORT} from "./testUtils.js"
+import {RpcErrors} from "../src/index.js"
+
+describe("Misc", () => {
+  it("Send array in parameter", async () => {
+    let param
+
+    const services = await startTestServer({
+      async hello(p) {
+        param = p
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    await client.hello(["a"])
+    assert.equal(typeof param, "object")
+    assert.isArray(param)
+  })
+
+  it("Circular reference in params", async () => {
+    let param: any
+
+    const services = await startTestServer({
+      async hello(p) {
+        param = p
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const msg = {
+      some: "string",
+      ref: null as any,
+    }
+    msg.ref = msg
+
+    await client.hello(msg)
+
+    assert.equal(param.some, msg.some)
+  })
+
+  it("Circular reference in response", async () => {
+    const msg = {
+      some: "string",
+      ref: null as any,
+    }
+    msg.ref = msg
+
+    const services = await startTestServer({
+      async hello() {
+        return msg
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const r = await client.hello()
+
+    assert.equal(r.some, msg.some)
+  })
+
+  it("date in response", async () => {
+    const date = new Date()
+
+    const msg = {
+      date,
+    }
+
+    const services = await startTestServer({
+      async hello() {
+        return msg
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const r = await client.hello()
+
+    assert.equal(r.date.getTime(), date.getTime())
+  })
+
+  it("date in params", async () => {
+    const date = new Date()
+
+    let receivedDate: Date | undefined
+
+    const services = await startTestServer({
+      async hello(d: Date) {
+        receivedDate = d
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    await client.hello(date)
+    assert.equal(receivedDate!.getTime(), date.getTime())
+  })
+
+  it("null member in local", async () => {
+    await startTestServer({
+      nested: null,
+    } as any)
+  })
+
+  it("recursive member in local", async () => {
+    const local = {
+      nested: null as unknown,
+    }
+
+    local.nested = local
+
+    await startTestServer(local as any)
+  })
+
+  it("Non flat remote", async () => {
+    const services = await startTestServer({
+      async hello1() {
+        return "yes1"
+      },
+
+      nested: {
+        async hello2() {
+          return "yes2"
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    assert.equal("yes1", await client.hello1())
+    assert.equal("yes2", await client.nested.hello2())
+  })
+
+  it("Item not found", async () => {
+    await startTestServer({
+      async hello1() {
+        return "yes1"
+      },
+
+      nested: {
+        async hello2() {
+          return "yes2"
+        },
+      },
+    })
+
+    const remote: any = await createTestClient<any>()
+
+    try {
+      await remote.hello()
+      assert.fail("Error expected")
+    } catch (e: any) {
+      assert.equal(e.code, RpcErrors.NotFound)
+    }
+
+    try {
+      await remote.nested.hello()
+      assert.fail("Error expected")
+    } catch (e: any) {
+      assert.equal(e.code, RpcErrors.NotFound)
+    }
+
+    try {
+      await remote.nested.nested2.hello()
+      assert.fail("Error expected")
+    } catch (e: any) {
+      assert.equal(e.code, RpcErrors.NotFound)
+    }
+  })
+
+  it("invoke with empty body", async () => {
+    await startTestServer({
+      async hello1() {
+        return "yes1"
+      },
+    })
+
+    const r = await fetch(`http://127.0.0.1:${TEST_PORT}/rpc/hello1`, {
+      method: "POST",
+    })
+
+    const body = await r.text()
+    assert.equal(body, "yes1")
+  })
+})