@push-rpc/next 2.0.0-beta.1

package/src/server/local.ts

@@ -0,0 +1,80 @@
+import {RemoteFunction, Services} from "../rpc.js"
+import {LocalSubscriptions} from "./LocalSubscriptions.js"
+import {ExtractPromiseResult} from "../utils/types.js"
+import {ThrottleArgsReducer} from "../utils/throttle.js"
+
+export type ThrottleSettings<D> = {
+  timeout: number
+  reducer?: ThrottleArgsReducer<D>
+}
+
+export function withTriggers<T extends Services<T>>(
+  localSubscriptions: LocalSubscriptions,
+  services: T,
+  name = ""
+): ServicesWithTriggers<T> {
+  const cachedItems: any = {}
+  const skippedProps = ["length", "name", "prototype", "arguments", "caller"]
+
+  return new Proxy(services, {
+    get(target: any, propName: string) {
+      // skip internal props
+      if (typeof propName != "string") return target[propName]
+
+      // skip other system props
+      if (["then", "catch", "toJSON", ...skippedProps].includes(propName)) return target[propName]
+
+      const itemName = name ? name + "/" + propName : propName
+
+      if (typeof target[propName] == "function") {
+        const delegate = (...params: unknown[]) => {
+          return target[propName](...params)
+        }
+
+        delegate.trigger = (filter: Record<string, unknown> = {}, suppliedData?: unknown) => {
+          // triggers are delayed for consumers to receive updates after the current call ends.
+          setTimeout(() => {
+            localSubscriptions.trigger(itemName, filter, suppliedData)
+          }, 0)
+        }
+
+        delegate.throttle = (settings: ThrottleSettings<unknown>) => {
+          localSubscriptions.throttleItem(itemName, settings)
+        }
+
+        return delegate
+      } else if (!cachedItems[propName]) {
+        cachedItems[propName] = withTriggers(
+          localSubscriptions,
+          services[propName as keyof T] as any,
+          itemName
+        )
+      }
+
+      return cachedItems[propName]
+    },
+
+    set(target, propName, value) {
+      cachedItems[propName] = value
+      return true
+    },
+
+    ownKeys() {
+      return [...skippedProps, ...Object.keys(cachedItems)]
+    },
+  })
+}
+
+export type ServicesWithTriggers<T extends Services<T>> = {
+  [K in keyof T]: T[K] extends RemoteFunction
+    ? T[K] & {
+        trigger(
+          filter?: Partial<Parameters<T[K]>[0]>,
+          suppliedData?: ExtractPromiseResult<ReturnType<T[K]>>
+        ): void
+        throttle(settings: ThrottleSettings<ExtractPromiseResult<ReturnType<T[K]>>>): void
+      }
+    : T[K] extends object
+      ? ServicesWithTriggers<T[K]>
+      : never
+}

package/src/utils/json.ts

@@ -0,0 +1,32 @@
+import stringify from "fast-stringify"
+
+export function safeStringify(value: any): string {
+  // @ts-ignore
+  return stringify(value)
+}
+
+export function safeParseJson(json: string): any {
+  return JSON.parse(json, dateReviver)
+}
+
+function dateReviver(key: string, val: any) {
+  if (typeof val == "string") {
+    if (ISO8601_secs.test(val)) {
+      return new Date(val)
+    }
+
+    if (ISO8601.test(val)) {
+      return new Date(val)
+    }
+
+    if (ISO8601_date.test(val)) {
+      return new Date(val)
+    }
+  }
+
+  return val
+}
+
+const ISO8601 = /^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ$/
+const ISO8601_secs = /^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ$/
+const ISO8601_date = /^\d\d\d\d-\d\d-\d\d$/

package/src/utils/middleware.ts

@@ -0,0 +1,38 @@
+export type Middleware<Context> = (
+  ctx: Context,
+  next: (...params: unknown[]) => Promise<unknown>,
+  ...params: unknown[]
+) => Promise<unknown>
+
+export function withMiddlewares<Context>(
+  ctx: Context,
+  middlewares: Middleware<Context>[],
+  final: (...params: unknown[]) => Promise<unknown>,
+  ...params: any
+) {
+  return (function (next, ...params) {
+    let index = -1
+    return dispatch(0, ...params)
+
+    function dispatch(i: number, ...p: unknown[]): Promise<unknown> {
+      if (i <= index) return Promise.reject(new Error("next() called multiple times"))
+
+      // use previous invocation params
+      if (!p.length) {
+        p = params
+      }
+
+      index = i
+
+      try {
+        if (i === middlewares.length) {
+          return Promise.resolve(next(...p))
+        } else {
+          return Promise.resolve(middlewares[i](ctx, dispatch.bind(null, i + 1), ...p))
+        }
+      } catch (err) {
+        return Promise.reject(err)
+      }
+    }
+  })(final, ...params)
+}

package/src/utils/promises.ts

@@ -0,0 +1,25 @@
+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/src/utils/throttle.ts

@@ -0,0 +1,48 @@
+export type ThrottleArgsReducer<D> = (prevValue: D, newValue: D) => D
+
+export function lastValueReducer<D>(prevValue: D, newValue: D): D {
+  return newValue
+}
+
+export function groupReducer<D>(prevValue: D[], newValue: D[]): D[] {
+  if (!Array.isArray(newValue))
+    throw new Error("groupReducer should only be used with topics that return arrays")
+
+  return prevValue ? [...prevValue, ...newValue] : newValue
+}
+
+export function throttle<D>(
+  callback: (d: D) => void,
+  delay: number,
+  reducer: ThrottleArgsReducer<D>
+): (d: D) => void {
+  let timer: NodeJS.Timeout
+  let lastExec = 0
+
+  let reducedArg: any
+
+  function wrapper(this: any, d: D) {
+    let self = this
+    let elapsed = Date.now() - lastExec
+
+    function exec() {
+      lastExec = Date.now()
+      callback.call(self, reducedArg)
+      reducedArg = undefined
+    }
+
+    if (timer) {
+      clearTimeout(timer)
+    }
+
+    reducedArg = reducer(reducedArg, d)
+
+    if (elapsed > delay) {
+      exec()
+    } else {
+      timer = setTimeout(exec, delay - elapsed)
+    }
+  }
+
+  return wrapper
+}

package/src/utils/types.ts

@@ -0,0 +1 @@
+export type ExtractPromiseResult<Type> = Type extends Promise<infer X> ? X : never

package/tests/calls.ts

@@ -0,0 +1,215 @@
+import {assert} from "chai"
+import {createTestClient, startTestServer} from "./testUtils.js"
+import {CallOptions, RpcError, RpcErrors} from "../src/index.js"
+import {adelay} from "../src/utils/promises.js"
+
+describe("calls", () => {
+  it("client call server", async () => {
+    const resp = {r: "asf"}
+
+    const invocation = {
+      req: null as unknown,
+    }
+
+    const services = await startTestServer({
+      test: {
+        async getSomething(req: unknown) {
+          invocation.req = req
+          return resp
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const req = {key: "value"}
+    const r = await client.test.getSomething(req)
+
+    assert.deepEqual(invocation.req, req)
+    assert.deepEqual(r, resp)
+  })
+
+  it("error", async () => {
+    const message = "bla"
+
+    const services = await startTestServer({
+      test: {
+        async getSomething() {
+          throw new Error(message)
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    try {
+      await client.test.getSomething()
+      assert.fail()
+    } catch (e: any) {
+      console.log(e)
+      assert.equal(e.message, message)
+    }
+  })
+
+  it("timeout", async () => {
+    const callTimeout = 200
+
+    const services = await startTestServer({
+      test: {
+        async longOp() {
+          await new Promise((r) => setTimeout(r, 2 * callTimeout))
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>({
+      callTimeout,
+    })
+
+    try {
+      await client.test.longOp()
+      assert.fail()
+    } catch (e: any) {
+      assert.equal(e.code, RpcErrors.Timeout)
+    }
+  }).timeout(1000)
+
+  it("per-call timeout override default", 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(new CallOptions({timeout: callTimeout}))
+      assert.fail()
+    } catch (e: any) {
+      assert.equal(e.code, RpcErrors.Timeout)
+    }
+  }).timeout(5000)
+
+  it("binds this object", async () => {
+    const resp = {r: "asf"}
+
+    const ss = {
+      test: {
+        async getSomething() {
+          return this.method()
+        },
+
+        async method() {
+          return resp
+        },
+      },
+    }
+
+    const services = await startTestServer(ss)
+
+    const client = await createTestClient<typeof services>()
+
+    const r = await client.test.getSomething()
+    assert.deepEqual(r, resp)
+  })
+
+  it("binds this class", async () => {
+    const resp = {r: "asf"}
+
+    class B extends A {
+      async method() {
+        return resp
+      }
+
+      [x: string]: any
+    }
+
+    const services = {
+      test: new B(),
+    }
+
+    await startTestServer(services)
+
+    const client = await createTestClient<typeof services>()
+
+    const r = await client.test.getSomething()
+    assert.deepEqual(r, resp)
+  })
+
+  it("first level lookup", async () => {
+    const services = await startTestServer({
+      async hello() {
+        return "yes"
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const r = await client.hello()
+    assert.equal("yes", r)
+  })
+
+  it("nested lookup", async () => {
+    const services = await startTestServer({
+      obj: {
+        async hello() {
+          return "yes"
+        },
+      },
+    })
+
+    const client = await createTestClient<typeof services>()
+    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 {
+  async getSomething(): Promise<{r: string}> {
+    return this.method()
+  }
+
+  abstract method(): Promise<{r: string}>
+}

package/tests/connection.ts

@@ -0,0 +1,107 @@
+import {assert} from "chai"
+import {createTestClient, startTestServer, testClient, testServer} from "./testUtils.js"
+import WebSocket from "ws"
+import {adelay} from "../src/utils/promises.js"
+
+describe("connection", () => {
+  it("server close connection on ping timeout", async () => {
+    let oldPing: typeof WebSocket.prototype.ping
+
+    oldPing = WebSocket.prototype.ping
+    WebSocket.prototype.ping = () => {}
+
+    const pingInterval = 100
+
+    const services = await startTestServer(
+      {
+        test: {
+          async call() {},
+        },
+      },
+      {
+        pingInterval,
+      }
+    )
+
+    const remote = await createTestClient<typeof services>({
+      reconnectDelay: pingInterval * 4, // so we don't reconnect fast and can catch disconnected state
+    })
+
+    await remote.test.call.subscribe(() => {})
+    assert.equal(testServer?._allSubscriptions().length, 1)
+
+    // wait for timeout
+    await adelay(pingInterval * 2.5)
+
+    // should be closed
+    assert.equal(testServer?._allSubscriptions().length, 0)
+
+    WebSocket.prototype.ping = oldPing
+  }).timeout(5000)
+
+  it("client close connection on ping timeout", async () => {
+    const pingInterval = 100 // less than server pings, so client will close connection first
+
+    const services = await startTestServer({
+      test: {
+        async call() {},
+      },
+    })
+
+    const remote = await createTestClient<typeof services>({
+      pingInterval,
+      reconnectDelay: pingInterval * 4, // so we don't reconnect fast and can catch disconnected state
+    })
+
+    await remote.test.call.subscribe(() => {})
+
+    assert.equal(testClient?.isConnected(), true)
+
+    // wait for timeout
+    await new Promise((r) => setTimeout(r, pingInterval * 2))
+
+    // should be closed
+    assert.equal(testClient?.isConnected(), false)
+  })
+
+  it("client reconnects on disconnect", async () => {
+    const pingInterval = 100 // less than server pings, so client will close connection first
+
+    const services = await startTestServer({
+      test: {
+        async call() {},
+      },
+    })
+
+    const remote = await createTestClient<typeof services>({
+      pingInterval,
+      reconnectDelay: 0, // will reconnect after failed ping
+    })
+
+    await remote.test.call.subscribe(() => {})
+
+    assert.equal(testClient!.isConnected(), true)
+
+    // wait for timeout
+    await new Promise((r) => setTimeout(r, pingInterval * 2))
+
+    // should be reconnected again
+    assert.equal(testClient!.isConnected(), true)
+  })
+
+  it("close will stop reconnection loop", async () => {
+    const services = await startTestServer({
+      item: async () => "1",
+    })
+
+    const remote = await createTestClient<typeof services>()
+
+    await remote.item.subscribe(() => {})
+
+    assert.equal(testClient!.isConnected(), true)
+
+    await testClient!.close()
+
+    assert.equal(testClient!.isConnected(), false)
+  })
+})