@push-rpc/next 2.0.0-beta.1

package/src/client/RemoteSubscriptions.ts

@@ -0,0 +1,121 @@
+import {safeStringify} from "../utils/json.js"
+
+export class RemoteSubscriptions {
+  subscribe(
+    initialData: unknown,
+    itemName: string,
+    parameters: unknown[],
+    consumer: (d: unknown) => void
+  ) {
+    this.addSubscription(itemName, parameters, consumer)
+
+    this.consume(itemName, parameters, initialData)
+  }
+
+  unsubscribe(itemName: string, parameters: unknown[], consumer: (d: unknown) => void): boolean {
+    const parametersKey = getParametersKey(parameters)
+
+    return this.removeSubscription(itemName, parametersKey, consumer)
+  }
+
+  private addSubscription(itemName: string, parameters: unknown[], consumer: (d: unknown) => void) {
+    const itemSubscriptions = this.byItem.get(itemName) || {byParameters: new Map()}
+    this.byItem.set(itemName, itemSubscriptions)
+
+    const parametersKey = getParametersKey(parameters)
+    const parameterSubscriptions = itemSubscriptions.byParameters.get(parametersKey) || {
+      parameters,
+      cached: null,
+      consumers: [],
+    }
+    itemSubscriptions.byParameters.set(parametersKey, parameterSubscriptions)
+    parameterSubscriptions.consumers.push(consumer)
+  }
+
+  private removeSubscription(
+    itemName: string,
+    parametersKey: string,
+    consumer: (d: unknown) => void
+  ): boolean {
+    const itemSubscriptions = this.byItem.get(itemName)
+    if (!itemSubscriptions) return false
+
+    const filterSubscriptions = itemSubscriptions.byParameters.get(parametersKey)
+    if (!filterSubscriptions) return false
+
+    const index = filterSubscriptions.consumers.indexOf(consumer)
+    if (index == -1) return false
+
+    filterSubscriptions.consumers.splice(index, 1)
+
+    if (!filterSubscriptions.consumers.length) {
+      itemSubscriptions.byParameters.delete(parametersKey)
+
+      if (itemSubscriptions.byParameters.size == 0) {
+        this.byItem.delete(itemName)
+      }
+
+      return true
+    }
+
+    return false
+  }
+
+  getCached(itemName: string, parameters: unknown[]): unknown | undefined {
+    const parametersKey = getParametersKey(parameters)
+
+    const itemSubscriptions = this.byItem.get(itemName)
+    if (!itemSubscriptions) return
+
+    const filterSubscriptions = itemSubscriptions.byParameters.get(parametersKey)
+
+    return filterSubscriptions?.cached
+  }
+
+  consume(itemName: string, parameters: unknown[], data: unknown) {
+    const parametersKey = getParametersKey(parameters)
+
+    const itemSubscriptions = this.byItem.get(itemName)
+    if (!itemSubscriptions) return
+
+    const filterSubscriptions = itemSubscriptions.byParameters.get(parametersKey)
+
+    if (!filterSubscriptions) return
+
+    filterSubscriptions.cached = data
+    filterSubscriptions.consumers.forEach((consumer) => {
+      consumer(data)
+    })
+  }
+
+  getAllSubscriptions(): Array<
+    [itemName: string, parameters: unknown[], consumers: Array<(d: unknown) => void>]
+  > {
+    const result: Array<[string, unknown[], Array<(d: unknown) => void>]> = []
+
+    for (const [itemName, itemSubscriptions] of this.byItem) {
+      for (const [, parameterSubscriptions] of itemSubscriptions.byParameters) {
+        result.push([itemName, parameterSubscriptions.parameters, parameterSubscriptions.consumers])
+      }
+    }
+
+    return result
+  }
+
+  private byItem: Map<string, ItemSubscription> = new Map()
+}
+
+type ItemSubscription = {
+  byParameters: Map<
+    string,
+    {
+      parameters: unknown[]
+      cached: unknown
+      consumers: Array<(d: unknown) => void>
+    }
+  >
+}
+
+function getParametersKey(parameters: unknown[]) {
+  return safeStringify(parameters)
+}

package/src/client/RpcClientImpl.ts

@@ -0,0 +1,177 @@
+import {CallOptions, InvocationType, RpcContext, Services} from "../rpc.js"
+import {HttpClient} from "./HttpClient.js"
+import {RemoteSubscriptions} from "./RemoteSubscriptions.js"
+import {WebSocketConnection} from "./WebSocketConnection.js"
+import {nanoid} from "nanoid"
+import {createRemote, ServicesWithSubscriptions} from "./remote.js"
+import {ConsumeServicesOptions, RpcClient} from "./index.js"
+import {withMiddlewares} from "../utils/middleware.js"
+
+export class RpcClientImpl<S extends Services<S>> implements RpcClient {
+  constructor(
+    url: string,
+    private readonly options: ConsumeServicesOptions
+  ) {
+    this.httpClient = new HttpClient(url, this.clientId)
+    this.remoteSubscriptions = new RemoteSubscriptions()
+
+    this.connection = new WebSocketConnection(
+      url,
+      this.clientId,
+      {
+        errorDelayMaxDuration: options.errorDelayMaxDuration,
+        reconnectDelay: options.reconnectDelay,
+        pingInterval: options.pingInterval,
+      },
+      (itemName, parameters, data) => {
+        this.remoteSubscriptions.consume(itemName, parameters, data)
+      },
+      this.resubscribe
+    )
+  }
+
+  private readonly clientId = nanoid()
+  private readonly httpClient: HttpClient
+  private readonly remoteSubscriptions: RemoteSubscriptions
+  private readonly connection: WebSocketConnection
+
+  isConnected() {
+    return this.connection.isConnected()
+  }
+
+  close() {
+    return this.connection.close()
+  }
+
+  _allSubscriptions() {
+    const result: Array<
+      [itemName: string, parameters: unknown[], consumers: (d: unknown) => void]
+    > = []
+
+    for (const [
+      itemName,
+      parameters,
+      consumers,
+    ] of this.remoteSubscriptions.getAllSubscriptions()) {
+      for (const consumer of consumers) {
+        result.push([itemName, parameters, consumer])
+      }
+    }
+    return result
+  }
+
+  _webSocket() {
+    return this.connection._webSocket()
+  }
+
+  createRemote(): ServicesWithSubscriptions<S> {
+    return createRemote<S>({
+      call: this.call,
+      subscribe: this.subscribe,
+      unsubscribe: this.unsubscribe,
+    })
+  }
+
+  private call = (
+    itemName: string,
+    parameters: unknown[],
+    callOptions?: CallOptions
+  ): Promise<unknown> => {
+    return this.invoke(
+      itemName,
+      InvocationType.Call,
+      (...parameters) =>
+        this.httpClient.call(
+          itemName,
+          parameters,
+          callOptions?.timeout ?? this.options.callTimeout
+        ),
+      parameters
+    )
+  }
+
+  private subscribe = async (
+    itemName: string,
+    parameters: unknown[],
+    consumer: (d: unknown) => void,
+    callOptions?: CallOptions
+  ): Promise<void> => {
+    const cached = this.remoteSubscriptions.getCached(itemName, parameters)
+
+    if (cached !== undefined) {
+      consumer(cached)
+    }
+
+    if (this.options.subscribe) {
+      this.connection.connect().catch((e) => {
+        // ignored
+      })
+    }
+
+    const data = await this.invoke(
+      itemName,
+      InvocationType.Subscribe,
+      (...parameters) =>
+        this.httpClient.subscribe(
+          itemName,
+          parameters,
+          callOptions?.timeout ?? this.options.callTimeout
+        ),
+      parameters
+    )
+    this.remoteSubscriptions.subscribe(data, itemName, parameters, consumer)
+  }
+
+  private unsubscribe = async (
+    itemName: string,
+    parameters: unknown[],
+    consumer: (d: unknown) => void,
+    callOptions?: CallOptions
+  ) => {
+    const noSubscriptionsLeft = this.remoteSubscriptions.unsubscribe(itemName, parameters, consumer)
+
+    if (noSubscriptionsLeft) {
+      await this.invoke(
+        itemName,
+        InvocationType.Unsubscribe,
+        (...parameters) =>
+          this.httpClient.unsubscribe(
+            itemName,
+            parameters,
+            callOptions?.timeout ?? this.options.callTimeout
+          ),
+        parameters
+      )
+    }
+  }
+
+  private resubscribe = () => {
+    for (const [itemName, params, consumers] of this.remoteSubscriptions.getAllSubscriptions()) {
+      this.httpClient
+        .subscribe(itemName, params, this.options.callTimeout)
+        .then((data) => {
+          this.remoteSubscriptions.consume(itemName, params, data)
+        })
+        .catch((e) => {
+          for (const consumer of consumers) {
+            this.remoteSubscriptions.unsubscribe(itemName, params, consumer)
+          }
+        })
+    }
+  }
+
+  private invoke(
+    itemName: string,
+    invocationType: InvocationType,
+    next: (...params: unknown[]) => Promise<unknown>,
+    parameters: unknown[]
+  ) {
+    const ctx: RpcContext = {
+      clientId: this.clientId,
+      itemName,
+      invocationType: invocationType,
+    }
+
+    return withMiddlewares(ctx, this.options.middleware, next, ...parameters)
+  }
+}

package/src/client/WebSocketConnection.ts

@@ -0,0 +1,183 @@
+import WebSocket from "ws"
+import {log} from "../logger.js"
+import {safeParseJson} from "../utils/json.js"
+import {adelay} from "../utils/promises.js"
+
+export class WebSocketConnection {
+  constructor(
+    private readonly url: string,
+    private readonly clientId: string,
+    private readonly options: {
+      reconnectDelay: number
+      errorDelayMaxDuration: number
+      pingInterval: number
+    },
+    private readonly consume: (itemName: string, parameters: unknown[], data: unknown) => void,
+    private readonly onConnected: () => void
+  ) {
+    this.url = url
+    this.clientId = clientId
+  }
+
+  async close() {
+    this.disconnectedMark = true
+
+    if (this.socket) {
+      this.socket!.terminate()
+      this.socket = null
+    }
+
+    if (this.pingTimeout) {
+      clearTimeout(this.pingTimeout)
+    }
+  }
+
+  /**
+   * Connect to the server, on each disconnect try to disconnect.
+   * Resolves at first successful connect. Reconnection loop continues even after resolution
+   * Never rejects
+   */
+  connect() {
+    if (this.socket || !this.disconnectedMark) return Promise.resolve()
+
+    this.disconnectedMark = false
+
+    return new Promise<void>(async (resolve) => {
+      let onFirstConnection = resolve
+      let errorDelay = 0
+
+      while (true) {
+        // connect, and wait for ...
+        await new Promise<void>((resolve) => {
+          // 1. ...disconnected
+          const connectionPromise = this.establishConnection(resolve)
+
+          connectionPromise.then(
+            () => {
+              // first reconnect after successful connection is done without delay
+              errorDelay = 0
+
+              // signal about first connection
+              onFirstConnection()
+              onFirstConnection = () => {}
+            },
+            () => {
+              // 2. ... unable to establish connection
+              resolve()
+            }
+          )
+        })
+
+        // disconnected while connecting?
+        if (this.disconnectedMark) {
+          return
+        }
+
+        await adelay(this.options.reconnectDelay + errorDelay)
+
+        // disconnected while waiting?
+        if (this.disconnectedMark) {
+          return
+        }
+
+        errorDelay = Math.round(Math.random() * this.options.errorDelayMaxDuration)
+      }
+    })
+  }
+
+  public isConnected() {
+    return this.socket !== null
+  }
+
+  /**
+   * Connect this to server
+   *
+   * Resolves on successful connection, rejects on connection error or connection timeout
+   */
+  private async establishConnection(onDisconnected: () => void): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const socket = new WebSocket(this.url, this.clientId)
+
+        let connected = false
+
+        socket.on("open", () => {
+          this.socket = socket
+          connected = true
+          resolve()
+
+          this.heartbeat()
+
+          this.onConnected()
+        })
+
+        socket.on("ping", () => {
+          this.heartbeat()
+        })
+
+        socket.on("close", () => {
+          this.socket = null
+
+          if (connected) {
+            onDisconnected()
+          }
+
+          if (this.pingTimeout) {
+            clearTimeout(this.pingTimeout)
+          }
+        })
+
+        socket.on("error", (e) => {
+          if (!connected) {
+            reject(e)
+          }
+
+          log.warn("WS connection error", e.message)
+
+          try {
+            socket.close()
+          } catch (e) {
+            // ignore
+          }
+        })
+
+        socket.on("message", (message) => {
+          this.receiveSocketMessage(message)
+        })
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+
+  private socket: WebSocket | null = null
+  private disconnectedMark = true
+  private pingTimeout: NodeJS.Timeout | null = null
+
+  private heartbeat() {
+    if (this.pingTimeout) {
+      clearTimeout(this.pingTimeout)
+    }
+
+    this.pingTimeout = setTimeout(() => {
+      this.socket?.terminate()
+    }, this.options.pingInterval * 1.5)
+  }
+
+  private async receiveSocketMessage(rawMessage: WebSocket.RawData) {
+    try {
+      const msg = rawMessage.toString()
+
+      const [itemName, data, ...parameters] = safeParseJson(msg)
+
+      this.consume(itemName, parameters, data)
+    } catch (e) {
+      log.warn("Invalid message received", e)
+    }
+  }
+
+  // test-only
+  _webSocket() {
+    return this.socket
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,56 @@
+import {RpcContext, Services} from "../rpc.js"
+import {ServicesWithSubscriptions} from "./remote.js"
+import WebSocket from "ws"
+import {RpcClientImpl} from "./RpcClientImpl.js"
+import {Middleware} from "../utils/middleware.js"
+
+export type RpcClient = {
+  isConnected(): boolean
+  close(): Promise<void>
+
+  // test-only
+  _allSubscriptions(): Array<any[]>
+  _webSocket(): WebSocket | null
+}
+
+export type ConsumeServicesOptions = {
+  callTimeout: number
+  subscribe: boolean
+  reconnectDelay: number
+  errorDelayMaxDuration: number
+  pingInterval: number
+  middleware: Middleware<RpcContext>[]
+}
+
+export async function consumeServices<S extends Services<S>>(
+  url: string,
+  overrideOptions: Partial<ConsumeServicesOptions> = {}
+): Promise<{
+  client: RpcClient
+  remote: ServicesWithSubscriptions<S>
+}> {
+  if (url.endsWith("/")) {
+    throw new Error("URL must not end with /")
+  }
+
+  const options = {
+    ...defaultOptions,
+    ...overrideOptions,
+  }
+
+  const client = new RpcClientImpl<S>(url, options)
+
+  return {
+    client,
+    remote: client.createRemote(),
+  }
+}
+
+const defaultOptions: ConsumeServicesOptions = {
+  callTimeout: 5 * 1000,
+  subscribe: true,
+  reconnectDelay: 0,
+  errorDelayMaxDuration: 15 * 1000,
+  pingInterval: 30 * 1000, // should be in-sync with server
+  middleware: [],
+}

package/src/client/remote.ts

@@ -0,0 +1,118 @@
+import {CallOptions, Consumer, RemoteFunction, Services} from "../rpc.js"
+
+export function createRemote<S extends Services<S>>(
+  hooks: RemoteHooks,
+  name = ""
+): ServicesWithSubscriptions<S> {
+  // start with remote function
+  const remoteItem = (...paramsWithCallOptions: unknown[]) => {
+    const {params, callOptions} = extractCallOptions(paramsWithCallOptions)
+
+    return hooks.call(name, params, callOptions)
+  }
+
+  // add subscription methods
+  const subscription = {
+    subscribe: (consumer: (d: unknown) => void, ...paramsWithCallOptions: unknown[]) => {
+      const {params, callOptions} = extractCallOptions(paramsWithCallOptions)
+      return hooks.subscribe(name, params, consumer, callOptions)
+    },
+    unsubscribe: (consumer: (d: unknown) => void, ...paramsWithCallOptions: unknown[]) => {
+      const {params, callOptions} = extractCallOptions(paramsWithCallOptions)
+      return hooks.unsubscribe(name, params, consumer, callOptions)
+    },
+  }
+
+  Object.assign(remoteItem, subscription)
+
+  // then add proxy creating subitems
+
+  const cachedItems: any = {}
+
+  return new Proxy(remoteItem, {
+    get(target: any, propName: any) {
+      // skip internal props
+      if (typeof propName != "string") return target[propName]
+
+      // skip other system props
+      if (["then", "catch", "toJSON", ...skippedRemoteProps].includes(propName))
+        return target[propName]
+
+      // skip subscription methods
+      if (Object.keys(subscription).includes(propName)) return target[propName]
+
+      if (!cachedItems[propName]) {
+        cachedItems[propName] = createRemote(hooks, name ? name + "/" + propName : propName)
+      }
+
+      return cachedItems[propName]
+    },
+
+    set(target, propName, value) {
+      cachedItems[propName] = value
+      return true
+    },
+
+    // Used in resubscribe
+    ownKeys() {
+      return [...skippedRemoteProps, ...Object.keys(cachedItems)]
+    },
+  })
+}
+
+function extractCallOptions(params: unknown[]): {params: unknown[]; callOptions?: CallOptions} {
+  if (
+    params.length > 0 &&
+    typeof params[params.length - 1] == "object" &&
+    params[params.length - 1] != null &&
+    (params[params.length - 1] as any).kind == CallOptions.KIND
+  ) {
+    const options = params.pop() as CallOptions
+    return {
+      params,
+      callOptions: options,
+    }
+  }
+
+  return {params}
+}
+
+export type RemoteHooks = {
+  call(itemName: string, parameters: unknown[], callOptions?: CallOptions): Promise<unknown>
+  subscribe(
+    itemName: string,
+    parameters: unknown[],
+    consumer: (d: unknown) => void,
+    callOptions?: CallOptions
+  ): Promise<void>
+  unsubscribe(
+    itemName: string,
+    parameters: unknown[],
+    consumer: (d: unknown) => void,
+    callOptions?: CallOptions
+  ): Promise<void>
+}
+
+export type AddParameters<
+  TFunction extends (...args: any) => any,
+  TParameters extends [...args: any],
+> = (...args: [...Parameters<TFunction>, ...TParameters]) => ReturnType<TFunction>
+
+export type ServicesWithSubscriptions<T extends Services<T>> = {
+  [K in keyof T]: T[K] extends RemoteFunction
+    ? AddParameters<T[K], [CallOptions?]> & {
+        subscribe(
+          consumer: Consumer<T[K]>,
+          ...parameters: [...Parameters<T[K]>, CallOptions?]
+        ): Promise<void>
+        unsubscribe(
+          consumer: Consumer<T[K]>,
+          ...parameters: [...Parameters<T[K]>, CallOptions?]
+        ): Promise<void>
+      }
+    : T[K] extends object
+      ? ServicesWithSubscriptions<T[K]>
+      : never
+}
+
+const skippedRemoteProps = ["length", "name", "prototype", "arguments", "caller"]

package/src/index.ts

@@ -0,0 +1,18 @@
+export type {RemoteFunction, Services, Consumer, RpcContext, RpcConnectionContext} from "./rpc.js"
+export {RpcError, RpcErrors, CallOptions} from "./rpc.js"
+
+export type {Middleware} from "./utils/middleware.js"
+export {withMiddlewares} from "./utils/middleware.js"
+
+export type {RpcServer, PublishServicesOptions} from "./server/index.js"
+export {publishServices} from "./server/index.js"
+
+export type {ServicesWithTriggers} from "./server/local.js"
+
+export type {RpcClient, ConsumeServicesOptions} from "./client/index.js"
+export {consumeServices} from "./client/index.js"
+
+export type {ServicesWithSubscriptions} from "./client/remote.js"
+
+export {log, setLogger} from "./logger.js"
+export {safeStringify, safeParseJson} from "./utils/json.js"

package/src/logger.ts

@@ -0,0 +1,12 @@
+export interface Logger {
+  info(s: unknown, ...params: unknown[]): void
+  error(s: unknown, ...params: unknown[]): void
+  warn(s: unknown, ...params: unknown[]): void
+  debug(s: unknown, ...params: unknown[]): void
+}
+
+export let log: Logger = console
+
+export function setLogger(l: Logger) {
+  log = l
+}