@push-rpc/next 2.0.19 → 2.0.21

package/src/server/RpcServerImpl.ts

@@ -2,7 +2,6 @@ import {PublishServicesOptions, RpcServer} from "./index.js"
 import {LocalSubscriptions} from "./LocalSubscriptions.js"
 import http from "http"
 import type {ConnectionsServer} from "./ConnectionsServer.js"
-import {PromiseCache} from "../utils/promises.js"
 import {serveHttpRequest} from "./http.js"
 import {
   InvocationType,
@@ -21,7 +20,7 @@ import {safeParseJson, safeStringify} from "../utils/json.js"
 export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implements RpcServer {
   constructor(
     private readonly services: S,
-    private readonly options: PublishServicesOptions<C>
+    private readonly options: PublishServicesOptions<C>,
   ) {
     if ("server" in this.options) {
       this.httpServer = this.options.server
@@ -50,7 +49,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
         res,
         options.path,
         options.createServerHooks ? options.createServerHooks(hooks, req) : hooks,
-        options.createConnectionContext
+        options.createConnectionContext,
       ).catch((e) => {
         log.warn("Unhandled error serving HTTP request", e)
       })
@@ -66,7 +65,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
       (clientId) => {
         this.localSubscriptions.unsubscribeAll(clientId)
       },
-      !("server" in this.options)
+      !("server" in this.options),
     )
   }
 
@@ -114,14 +113,13 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
   }
 
   private readonly localSubscriptions = new LocalSubscriptions()
-  private readonly invocationCache = new PromiseCache()
   private connectionsServer: ConnectionsServer | null = null
   readonly httpServer
 
   private call = async (
     connectionContext: RpcConnectionContext,
     itemName: string,
-    parameters: unknown[]
+    parameters: unknown[],
   ): Promise<unknown> => {
     const item = this.getRemoteFunction(itemName)
 
@@ -135,7 +133,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
         itemName,
         item,
         parameters,
-        InvocationType.Call
+        InvocationType.Call,
       )
     } catch (e) {
       log.error(`Cannot call item ${itemName}.`, e)
@@ -146,7 +144,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
   private subscribe = async (
     connectionContext: RpcConnectionContext,
     itemName: string,
-    parameters: unknown[]
+    parameters: unknown[],
   ) => {
     const item = this.getRemoteFunction(itemName)
 
@@ -167,7 +165,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
                   itemName,
                   item,
                   parameters,
-                  InvocationType.Trigger
+                  InvocationType.Trigger,
                 )
 
           const newDataJson = safeStringify(newData)
@@ -178,7 +176,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
               connectionContext.clientId,
               itemName,
               parameters,
-              newData
+              newData,
             )
           }
         } catch (e) {
@@ -186,14 +184,16 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
         }
       })
 
-      this.localSubscriptions.subscribe(connectionContext.clientId, itemName, parameters, update)
+      if (this.connectionsServer?.isClientSubscribed(connectionContext.clientId)) {
+        this.localSubscriptions.subscribe(connectionContext.clientId, itemName, parameters, update)
+      }
 
       const lastData = await this.invokeLocalFunction(
         connectionContext,
         itemName,
         item,
         parameters,
-        InvocationType.Subscribe
+        InvocationType.Subscribe,
       )
       lastDataJson = safeStringify(lastData)
 
@@ -209,7 +209,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
   private unsubscribe = async (
     connectionContext: RpcConnectionContext,
     itemName: string,
-    parameters: unknown[]
+    parameters: unknown[],
   ) => {
     try {
       this.localSubscriptions.unsubscribe(connectionContext.clientId, itemName, parameters)
@@ -221,7 +221,7 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
 
   private getRemoteFunction(
     itemName: string,
-    root: any = this.services
+    root: any = this.services,
   ): {function: RemoteFunction; container: any} | undefined {
     const parts = itemName.split("/")
 
@@ -248,22 +248,18 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
     itemName: string,
     item: {function: RemoteFunction; container: any},
     parameters: unknown[],
-    invocationType: InvocationType
+    invocationType: InvocationType,
   ): Promise<unknown> {
-    return this.invocationCache.invoke(
-      {clientId: connectionContext.clientId, itemName, parameters},
-      () => {
-        const parametersCopy: unknown[] = safeParseJson(safeStringify(parameters))
+    const parametersCopy: unknown[] = safeParseJson(safeStringify(parameters))
 
-        const ctx = safeParseJson(safeStringify(connectionContext)) as C
-        ctx.itemName = itemName
-        ctx.invocationType = invocationType
+    const ctx = safeParseJson(safeStringify(connectionContext)) as C
+    ctx.itemName = itemName
+    ctx.invocationType = invocationType
 
-        const invokeItem = (...params: unknown[]) => {
-          return item.function.call(item.container, ...params, ctx)
-        }
-        return withMiddlewares<C>(ctx, this.options.middleware, invokeItem, ...parametersCopy)
-      }
-    )
+    const invokeItem = (...params: unknown[]) => {
+      return item.function.call(item.container, ...params, ctx)
+    }
+
+    return withMiddlewares<C>(ctx, this.options.middleware, invokeItem, ...parametersCopy)
   }
 }

package/src/utils/promises.ts

@@ -1,25 +1,3 @@
-export class PromiseCache {
-  invoke<T>(cacheKey: unknown, supplier: () => Promise<T>): Promise<T> {
-    const key = JSON.stringify(cacheKey)
-
-    if (!this.cache[key]) {
-      this.cache[key] = supplier()
-        .then((r) => {
-          delete this.cache[key]
-          return r
-        })
-        .catch((e) => {
-          delete this.cache[key]
-          throw e
-        })
-    }
-
-    return this.cache[key]
-  }
-
-  private cache: {[key: string]: Promise<any>} = {}
-}
-
 export async function adelay(ms: number) {
   return new Promise((r) => setTimeout(r, ms))
 }

package/tests/calls.ts

@@ -1,6 +1,6 @@
 import {assert} from "chai"
 import {createTestClient, startTestServer} from "./testUtils.js"
-import {CallOptions, RpcError, RpcErrors} from "../src/index.js"
+import {CallOptions, RpcErrors} from "../src/index.js"
 import {adelay} from "../src/utils/promises.js"
 
 describe("calls", () => {
@@ -169,41 +169,6 @@ describe("calls", () => {
     const r = await client.obj.hello()
     assert.equal("yes", r)
   })
-
-  it("concurrent call 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().then((item) => {
-      item1 = item
-    })
-
-    let item2
-    client.test.item().then((item) => {
-      item2 = item
-    })
-
-    await adelay(50)
-    assert.deepEqual(item1, item)
-    assert.deepEqual(item2, item)
-
-    assert.equal(supplied, 1)
-  })
 })
 
 abstract class A {

package/tests/context.ts

@@ -1,4 +1,4 @@
-import {createTestClient, startTestServer} from "./testUtils.js"
+import {createTestClient, startTestServer, testClient, testServer} from "./testUtils.js"
 import {assert} from "chai"
 import {adelay} from "../src/utils/promises.js"
 import {RpcContext} from "../src/index.js"
@@ -41,7 +41,7 @@ describe("context", () => {
         async createConnectionContext() {
           return {clientId: "test", newKey: "bla"}
         },
-      }
+      },
     )
 
     const client = await createTestClient<typeof services>()
@@ -75,30 +75,25 @@ describe("context", () => {
   it("available in trigger", async () => {
     let ctx = null
 
-    const services = await startTestServer(
-      {
-        test: {
-          async call(passedCtx?: any) {
-            ctx = passedCtx
-          },
+    const services = await startTestServer({
+      test: {
+        async call(passedCtx?: any) {
+          ctx = passedCtx
         },
       },
-      {
-        async createConnectionContext() {
-          return {clientId: "test"}
-        },
-      }
-    )
+    })
 
-    const client = await createTestClient<typeof services>()
+    const client = await createTestClient<typeof services>({
+      connectOnCreate: true,
+    })
 
     await client.test.call.subscribe(() => {})
-    assert.equal(ctx!.clientId, "test")
+    assert.equal(ctx!.clientId, testClient?.clientId)
 
     ctx = null
     services.test.call.trigger()
     await adelay(20)
-    assert.equal(ctx!.clientId, "test")
+    assert.equal(ctx!.clientId, testClient?.clientId)
     assert.equal(ctx!.invocationType, InvocationType.Trigger)
   })
 
@@ -107,26 +102,19 @@ describe("context", () => {
 
     let count = 0
 
-    const services = await startTestServer(
-      {
-        test: {
-          async call(passedCtx?: any) {
-            ctx = passedCtx
+    const services = await startTestServer({
+      test: {
+        async call(passedCtx?: any) {
+          ctx = passedCtx
 
-            if (!count) {
-              ctx.modified = true
-            }
+          if (!count) {
+            ctx.modified = true
+          }
 
-            count++
-          },
+          count++
         },
       },
-      {
-        async createConnectionContext() {
-          return {clientId: "test"}
-        },
-      }
-    )
+    })
 
     const client = await createTestClient<typeof services>()
 
@@ -160,7 +148,7 @@ describe("context", () => {
             return next(ctx)
           },
         ],
-      }
+      },
     )
 
     const client = await createTestClient<typeof services>()

package/tests/middleware.ts

@@ -44,7 +44,7 @@ describe("middleware", () => {
             return next()
           },
         ],
-      }
+      },
     )
 
     const remote = await createTestClient<typeof services>()
@@ -128,6 +128,7 @@ describe("middleware", () => {
           return next((r as number) + 1)
         },
       ],
+      connectOnCreate: true,
     })
 
     let response
@@ -135,9 +136,12 @@ describe("middleware", () => {
       (r) => {
         response = r
       },
-      {param: 1}
+      {param: 1},
     )
 
+    assert.equal(response, 1)
+    assert.equal(count, 2)
+
     services.remote.trigger({param: 1})
 
     await adelay(20)
@@ -172,6 +176,7 @@ describe("middleware", () => {
           throw new Error("Test error")
         },
       ],
+      connectOnCreate: true,
     })
 
     await client.remote.subscribe((r) => {
@@ -227,7 +232,7 @@ describe("middleware", () => {
             throw new Error("Error")
           },
         ],
-      }
+      },
     )
 
     const client = await createTestClient<typeof services>({})

package/tests/subscriptions.ts

@@ -1,10 +1,8 @@
 import {assert} from "chai"
 import {createTestClient, startTestServer, testClient, testServer} from "./testUtils.js"
 import {adelay} from "../src/utils/promises.js"
-import {CallOptions, RpcConnectionContext, RpcErrors} from "../src/index.js"
-import {IncomingMessage} from "http"
-import {CLIENT_ID_HEADER} from "../src/rpc.js"
-import WebSocket from "ws"
+import {CallOptions, RpcErrors} from "../src/index.js"
+import {setTestWebSocketConnectionDelay} from "../src/client/WebSocketConnection.js"
 
 describe("Subscriptions", () => {
   it("subscribe delivers data", async () => {
@@ -140,41 +138,6 @@ describe("Subscriptions", () => {
     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(20)
-          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"}
 
@@ -482,23 +445,7 @@ describe("Subscriptions", () => {
     })
 
     // delay client connection open by 10ms
-    let oldAddEL: typeof WebSocket.prototype.addEventListener
-
-    oldAddEL = WebSocket.prototype.addEventListener
-    WebSocket.prototype.addEventListener = function (eventName: any, callback: any) {
-      if (eventName == "open") {
-        oldAddEL.apply(this, [
-          eventName,
-          () => {
-            setTimeout(callback, 10)
-          },
-        ])
-
-        return
-      }
-
-      return oldAddEL.apply(this, [eventName, callback])
-    }
+    delayWebsocketConnection(10)
 
     const client = await createTestClient<typeof services>()
 
@@ -514,7 +461,7 @@ describe("Subscriptions", () => {
     assert.equal(testClient!._allSubscriptions().length, 0)
     assert.equal(testServer!._allSubscriptions().length, 0)
 
-    WebSocket.prototype.addEventListener = oldAddEL
+    cancelWebsocketConnectionDelay()
   })
 
   it("skip unchanged data", async () => {
@@ -587,6 +534,7 @@ describe("Subscriptions", () => {
 
     const client = await createTestClient<typeof services>({
       callTimeout: 2 * delay,
+      connectOnCreate: true,
     })
 
     let received = 0
@@ -605,6 +553,8 @@ describe("Subscriptions", () => {
     assert.equal(received, 2)
   })
 
+  // Currently not working, b/c paused is boolean
+  // To implement it, need to replace it with counter
   it.skip("two concurrent subscribes and trigger", async () => {
     const delay = 50
 
@@ -694,62 +644,133 @@ describe("Subscriptions", () => {
     assert.equal(received, 1)
   })
 
-  it("subscribe waits for connection", async () => {
-    const delay = 50
+  it("can subscribe while disconnected", async () => {
+    const item = {r: "1"}
 
-    let connectedClients = 0
-    let serverCalled = 0
+    delayWebsocketConnection(50)
 
-    const services = await startTestServer(
-      {
-        test: {
-          async op(params: {key: number}): Promise<number> {
-            serverCalled++
-            return 1
-          },
-        },
+    const services = await startTestServer({
+      test: {
+        item: async () => item,
       },
-      {
-        async createConnectionContext(req: IncomingMessage): Promise<RpcConnectionContext> {
-          const header = req.headers[CLIENT_ID_HEADER]
+    })
 
-          connectedClients++
+    const remote = await createTestClient<typeof services>()
 
-          return {
-            clientId: (Array.isArray(header) ? header[0] : header) || "anon",
-          }
+    let receivedItem
+    await remote.test.item.subscribe((item) => {
+      receivedItem = item
+    })
+
+    assert.deepEqual(receivedItem, item)
+
+    // trigger sends item
+    item.r = "2"
+    services.test.item.trigger()
+    await adelay(60)
+    assert.deepEqual(receivedItem, item)
+
+    cancelWebsocketConnectionDelay()
+  })
+
+  it("connect during subscribe", async () => {
+    const item = {r: "1"}
+
+    delayWebsocketConnection(30)
+
+    const services = await startTestServer({
+      test: {
+        item: async () => {
+          await adelay(50)
+          return item
         },
       },
-    )
+    })
 
-    const client = await createTestClient<typeof services>({
-      callTimeout: 2 * delay,
+    const remote = await createTestClient<typeof services>()
+
+    let receivedItem
+    await remote.test.item.subscribe((item) => {
+      receivedItem = item
     })
 
-    let received1
-    let received2
+    assert.deepEqual(receivedItem, item)
+
+    // trigger sends item
+    item.r = "2"
+    services.test.item.trigger()
+    await adelay(100)
+    assert.deepEqual(receivedItem, item)
+
+    cancelWebsocketConnectionDelay()
+  })
+
+  it("disconnect during subscribe", async () => {
+    const item = {r: "1"}
 
-    client.test.op.subscribe(
-      (val) => {
-        received1 = val
+    const services = await startTestServer({
+      test: {
+        item: async () => item,
       },
-      {key: 1},
-    )
+    })
 
-    await adelay(40)
+    const consume1 = await createTestClient<typeof services>({
+      connectOnCreate: true,
+    })
+
+    let received = null
 
-    client.test.op.subscribe(
-      (val) => {
-        received2 = val
+    // disconnect WS
+    testClient!._webSocket()!.close()
+
+    await consume1.test.item.subscribe((item) => {
+      received = item
+    })
+
+    assert.deepEqual(received, item)
+
+    item.r = "2"
+    services.test.item.trigger()
+    await adelay(100)
+
+    // still getting the update b/c on WS reconnect client will resubscribe
+    assert.deepEqual(received, item)
+  })
+
+  it("do not add subscriptions without connection", async () => {
+    const item = {r: "1"}
+
+    delayWebsocketConnection(100)
+
+    const services = await startTestServer({
+      test: {
+        item: async () => {
+          return item
+        },
       },
-      {key: 2},
-    )
+    })
 
-    await adelay(1.5 * delay)
+    const remote = await createTestClient<typeof services>()
 
-    assert.equal(received1, 1)
-    assert.equal(received2, 1)
-    assert.equal(serverCalled, 2)
-    assert.equal(testServer!._allSubscriptions().length, 2)
+    let receivedItem
+    await remote.test.item.subscribe((item) => {
+      receivedItem = item
+    })
+
+    assert.deepEqual(receivedItem, item)
+
+    const length = testServer!._allSubscriptions().length
+
+    assert.equal(length, 0)
+
+    cancelWebsocketConnectionDelay()
   })
 })
+
+function delayWebsocketConnection(ms: number) {
+  setTestWebSocketConnectionDelay(ms)
+}
+
+function cancelWebsocketConnectionDelay() {
+  setTestWebSocketConnectionDelay(0)
+}

package/tests/testUtils.ts

@@ -20,7 +20,7 @@ export let testServer: RpcServer | null = null
 
 export async function startTestServer<S extends Services<S>, C extends RpcContext>(
   local: S,
-  options: Partial<PublishServicesOptions<C>> = {}
+  options: Partial<PublishServicesOptions<C>> = {},
 ): Promise<ServicesWithTriggers<S>> {
   const r = await publishServices<S, C>(local, {
     port: TEST_PORT,
@@ -34,7 +34,7 @@ export async function startTestServer<S extends Services<S>, C extends RpcContex
 export let testClient: RpcClient | null = null
 
 export async function createTestClient<S extends Services<S>>(
-  options?: Partial<ConsumeServicesOptions>
+  options?: Partial<ConsumeServicesOptions>,
 ): Promise<ServicesWithSubscriptions<S>> {
   if (!options) options = {}
   if (!options.middleware) options.middleware = []

package/tests/triggers.ts

@@ -22,7 +22,9 @@ describe("Subscription triggers", () => {
       timeout: 0,
     })
 
-    const remote = await createTestClient<typeof services>()
+    const remote = await createTestClient<typeof services>({
+      connectOnCreate: true,
+    })
 
     let item1
     let item2
@@ -68,7 +70,9 @@ describe("Subscription triggers", () => {
       timeout: throttleTimeout,
     })
 
-    const remote = await createTestClient<typeof services>()
+    const remote = await createTestClient<typeof services>({
+      connectOnCreate: true,
+    })
 
     let count = 0
     let item = null