@push-rpc/next 2.0.0-beta.1

package/src/rpc.ts

@@ -0,0 +1,51 @@
+import {ExtractPromiseResult} from "./utils/types.js"
+
+export type RemoteFunction = (...args: any[]) => Promise<any>
+export type Services<SubType> = {
+  [K in keyof SubType]: Services<SubType[K]> | RemoteFunction
+}
+
+export type Consumer<T extends RemoteFunction> = (data: ExtractPromiseResult<ReturnType<T>>) => void
+
+export class RpcError extends Error {
+  constructor(
+    public readonly code: number,
+    message?: string
+  ) {
+    super(message)
+  }
+}
+
+export enum RpcErrors {
+  NotFound = 404,
+  Timeout = 504,
+}
+
+export class CallOptions {
+  constructor(options: {timeout: number}) {
+    this.timeout = options.timeout
+  }
+
+  public readonly timeout
+  public readonly kind = CallOptions.KIND // to distinguish from other parameters in remote call
+
+  public static KIND = "CallOptions"
+}
+
+export const CLIENT_ID_HEADER = "x-rpc-client-id"
+
+export type RpcConnectionContext = {
+  clientId: string
+}
+
+export type RpcContext = RpcConnectionContext & {
+  itemName: string
+  invocationType: InvocationType
+}
+
+export enum InvocationType {
+  Call = "Call",
+  Subscribe = "Subscribe",
+  Unsubscribe = "Unsubscribe", // client only
+  Trigger = "Trigger", // server only
+}

package/src/server/ConnectionsServer.ts

@@ -0,0 +1,78 @@
+import {safeStringify} from "../utils/json.js"
+import WebSocket, {WebSocketServer} from "ws"
+import http from "http"
+import {log} from "../logger.js"
+
+export class ConnectionsServer {
+  constructor(
+    server: http.Server,
+    options: ConnectionsServerOptions,
+    connectionClosed: (clientId: string) => void
+  ) {
+    this.wss = new WebSocketServer({server, path: options.path})
+
+    this.wss.on("connection", (ws: WebSocket & {alive: boolean}) => {
+      ws.alive = true
+
+      const clientId = ws.protocol || "anon"
+      this.clientSockets.set(clientId, ws)
+
+      ws.on("error", (e: unknown) => {
+        log.error("Error in WS", e)
+      })
+
+      ws.on("close", () => {
+        this.clientSockets.delete(clientId)
+        connectionClosed(clientId)
+      })
+
+      ws.on("pong", () => {
+        ws.alive = true
+      })
+    })
+
+    const pingTimer = setInterval(() => {
+      this.clientSockets.forEach((ws) => {
+        if (!ws.alive) {
+          // missing 2nd keep-alive period
+          ws.terminate()
+          return
+        }
+
+        ws.alive = false
+        ws.ping()
+      })
+    }, options.pingInterval)
+
+    this.wss.on("close", () => {
+      clearInterval(pingTimer)
+    })
+  }
+
+  publish(clientId: string, itemName: string, parameters: unknown[], data: unknown) {
+    const message = [itemName, data, ...parameters]
+
+    const ws = this.clientSockets.get(clientId)
+
+    if (ws) {
+      ws.send(safeStringify(message))
+    }
+  }
+
+  private wss: WebSocketServer
+  private clientSockets = new Map<string, WebSocket & {alive: boolean}>()
+
+  async close() {
+    return new Promise<void>((resolve, reject) => {
+      this.wss.close((err) => {
+        if (err) reject(err)
+        else resolve()
+      })
+    })
+  }
+}
+
+export type ConnectionsServerOptions = {
+  pingInterval: number
+  path: string
+}

package/src/server/LocalSubscriptions.ts

@@ -0,0 +1,155 @@
+import {safeStringify} from "../utils/json.js"
+import {lastValueReducer, throttle} from "../utils/throttle.js"
+import {ThrottleSettings} from "./local.js"
+
+export class LocalSubscriptions {
+  subscribe(
+    clientId: string,
+    itemName: string,
+    parameters: unknown[],
+    update: (suppliedData?: unknown) => void
+  ) {
+    const itemSubscriptions = this.byItem.get(itemName) || {byFilter: new Map()}
+    this.byItem.set(itemName, itemSubscriptions)
+
+    const filterKey = getFilterKey(parameters)
+
+    const subscriptions: FilterSubscription = itemSubscriptions.byFilter.get(filterKey) || {
+      filter: parameters?.[0],
+      subscribedClients: [],
+    }
+    itemSubscriptions.byFilter.set(filterKey, subscriptions)
+
+    if (!subscriptions.subscribedClients.some((c) => c.clientId == clientId)) {
+      subscriptions.subscribedClients.push({clientId, update})
+    }
+  }
+
+  unsubscribe(clientId: string, itemName: string, parameters: unknown[]) {
+    const itemSubscriptions = this.byItem.get(itemName)
+    if (!itemSubscriptions) return
+
+    const filterKey = getFilterKey(parameters)
+
+    const subscriptions = itemSubscriptions.byFilter.get(filterKey)
+    if (!subscriptions) return
+
+    subscriptions.subscribedClients = subscriptions.subscribedClients.filter(
+      (subscription) => subscription.clientId != clientId
+    )
+
+    if (!subscriptions.subscribedClients.length) {
+      itemSubscriptions.byFilter.delete(filterKey)
+
+      if (itemSubscriptions.byFilter.size == 0) {
+        this.byItem.delete(itemName)
+      }
+    }
+  }
+
+  unsubscribeAll(clientId: string) {
+    for (const [itemName, itemSubscriptions] of this.byItem.entries()) {
+      for (const [filterKey, subscriptions] of itemSubscriptions.byFilter.entries()) {
+        subscriptions.subscribedClients = subscriptions.subscribedClients.filter(
+          (subscription) => subscription.clientId != clientId
+        )
+
+        if (!subscriptions.subscribedClients.length) {
+          itemSubscriptions.byFilter.delete(filterKey)
+        }
+      }
+
+      if (itemSubscriptions.byFilter.size == 0) {
+        this.byItem.delete(itemName)
+      }
+    }
+  }
+
+  trigger(itemName: string, triggerFilter: Record<string, unknown> = {}, suppliedData?: unknown) {
+    const itemSub = this.byItem.get(itemName)
+    if (!itemSub) return
+
+    for (const {filter: subscriptionFilter, subscribedClients} of itemSub.byFilter.values()) {
+      if (!filterContains(triggerFilter, subscriptionFilter)) continue
+
+      subscribedClients.forEach((subscribedClient) => {
+        subscribedClient.update(suppliedData)
+      })
+    }
+  }
+
+  throttled(itemName: string, f: (d: unknown) => void) {
+    const settings: ThrottleSettings<unknown> = this.itemThrottleSettings.get(itemName) || {
+      timeout: 500,
+      reducer: lastValueReducer,
+    }
+
+    if (!settings.timeout) return f
+
+    return throttle(f, settings.timeout, settings.reducer || lastValueReducer)
+  }
+
+  throttleItem(itemName: string, settings: ThrottleSettings<unknown>) {
+    this.itemThrottleSettings.set(itemName, settings)
+  }
+
+  private itemThrottleSettings: Map<string, ThrottleSettings<unknown>> = new Map()
+
+  private byItem: Map<string, ItemSubscription> = new Map()
+
+  // test-only
+  _allSubscriptions() {
+    const result: Array<[itemName: string, parameters: unknown[], consumer: unknown]> = []
+
+    for (const [itemName, itemSubscriptions] of this.byItem) {
+      for (const [, parameterSubscriptions] of itemSubscriptions.byFilter) {
+        for (const client of parameterSubscriptions.subscribedClients) {
+          result.push([itemName, [parameterSubscriptions.filter], client.clientId])
+        }
+      }
+    }
+
+    return result
+  }
+}
+
+type ItemSubscription = {
+  byFilter: Map<string, FilterSubscription>
+}
+
+type FilterSubscription = {
+  filter: Record<string, unknown>
+  subscribedClients: Array<SubscribedClient>
+}
+
+type SubscribedClient = {
+  clientId: string
+  update: (suppliedData?: unknown) => void
+}
+
+function filterContains(
+  triggerFilter: Record<string, unknown>,
+  subscriptionFilter: Record<string, unknown>
+): boolean {
+  if (subscriptionFilter == null) return true // subscribe to all data
+  if (triggerFilter == null) return true // all data modified
+
+  for (const key of Object.keys(subscriptionFilter)) {
+    if (triggerFilter[key] == undefined) continue
+    if (subscriptionFilter[key] == triggerFilter[key]) continue
+
+    if (Array.isArray(triggerFilter[key]) && Array.isArray(subscriptionFilter[key])) {
+      if (safeStringify(triggerFilter[key]) == safeStringify(subscriptionFilter[key])) {
+        continue
+      }
+    }
+
+    return false
+  }
+
+  return true
+}
+
+function getFilterKey(parameters: unknown[]) {
+  return safeStringify(parameters?.[0] ?? null)
+}

package/src/server/RpcServerImpl.ts

@@ -0,0 +1,252 @@
+import {PublishServicesOptions, RpcServer} from "./index.js"
+import {LocalSubscriptions} from "./LocalSubscriptions.js"
+import http from "http"
+import {ConnectionsServer} from "./ConnectionsServer.js"
+import {PromiseCache} from "../utils/promises.js"
+import {serveHttpRequest} from "./http.js"
+import {
+  InvocationType,
+  RemoteFunction,
+  RpcConnectionContext,
+  RpcContext,
+  RpcError,
+  RpcErrors,
+  Services,
+} from "../rpc.js"
+import {log} from "../logger.js"
+import {withMiddlewares} from "../utils/middleware.js"
+import {ServicesWithTriggers, withTriggers} from "./local.js"
+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>
+  ) {
+    if ("server" in this.options) {
+      this.httpServer = this.options.server
+    } else {
+      this.httpServer = http.createServer()
+
+      // for our own server, respond 404 on unhandled URLs
+      this.httpServer.addListener("request", (req, res) => {
+        if (!req.url?.startsWith(options.path)) {
+          res.statusCode = 404
+          res.end()
+          return
+        }
+      })
+    }
+
+    this.connectionsServer = new ConnectionsServer(
+      this.httpServer,
+      {pingInterval: options.pingInterval, path: options.path},
+      (clientId) => {
+        this.localSubscriptions.unsubscribeAll(clientId)
+      }
+    )
+
+    this.httpServer.addListener("request", (req, res) =>
+      serveHttpRequest(
+        req,
+        res,
+        options.path,
+        {
+          call: this.call,
+          subscribe: this.subscribe,
+          unsubscribe: this.unsubscribe,
+        },
+        options.createConnectionContext
+      )
+    )
+  }
+
+  start() {
+    if ("server" in this.options) {
+      return Promise.resolve()
+    }
+
+    if ("port" in this.options) {
+      const {port} = this.options
+
+      return new Promise<void>((resolve, reject) => {
+        this.httpServer.on("error", (err) => {
+          reject(err)
+        })
+
+        this.httpServer.listen(port, this.options.host, () => {
+          resolve()
+        })
+      })
+    }
+  }
+
+  async close() {
+    await this.connectionsServer.close()
+    await new Promise<void>((resolve, reject) => {
+      this.httpServer.closeIdleConnections()
+      this.httpServer.close((err) => {
+        if (err) reject(err)
+        else resolve(err)
+      })
+    })
+  }
+
+  createServicesWithTriggers(): ServicesWithTriggers<S> {
+    return withTriggers(this.localSubscriptions, this.services)
+  }
+
+  _allSubscriptions() {
+    return this.localSubscriptions._allSubscriptions()
+  }
+
+  private readonly localSubscriptions = new LocalSubscriptions()
+  private readonly invocationCache = new PromiseCache()
+  private readonly connectionsServer: ConnectionsServer
+  readonly httpServer
+
+  private call = async (
+    connectionContext: RpcConnectionContext,
+    itemName: string,
+    parameters: unknown[]
+  ): Promise<unknown> => {
+    const item = this.getRemoteFunction(itemName)
+
+    if (!item) {
+      throw new RpcError(RpcErrors.NotFound, `Item ${itemName} not found`)
+    }
+
+    try {
+      return await this.invokeLocalFunction(
+        connectionContext,
+        itemName,
+        item,
+        parameters,
+        InvocationType.Call
+      )
+    } catch (e) {
+      log.error(`Cannot call item ${itemName}.`, e)
+      throw e
+    }
+  }
+
+  private subscribe = async (
+    connectionContext: RpcConnectionContext,
+    itemName: string,
+    parameters: unknown[]
+  ) => {
+    const item = this.getRemoteFunction(itemName)
+
+    if (!item) {
+      throw new RpcError(RpcErrors.NotFound, `Item ${itemName} not found`)
+    }
+
+    try {
+      const lastData = await this.invokeLocalFunction(
+        connectionContext,
+        itemName,
+        item,
+        parameters,
+        InvocationType.Subscribe
+      )
+      let lastDataJson = safeStringify(lastData)
+
+      const update = this.localSubscriptions.throttled(itemName, async (suppliedData?: unknown) => {
+        try {
+          const newData =
+            suppliedData !== undefined
+              ? suppliedData
+              : await this.invokeLocalFunction(
+                  connectionContext,
+                  itemName,
+                  item,
+                  parameters,
+                  InvocationType.Trigger
+                )
+
+          const newDataJson = safeStringify(newData)
+
+          if (newDataJson != lastDataJson) {
+            lastDataJson = newDataJson
+            this.connectionsServer.publish(
+              connectionContext.clientId,
+              itemName,
+              parameters,
+              newData
+            )
+          }
+        } catch (e) {
+          log.error("Cannot get data for subscription", e)
+        }
+      })
+
+      this.localSubscriptions.subscribe(connectionContext.clientId, itemName, parameters, update)
+
+      return lastData
+    } catch (e) {
+      log.error(`Failed to subscribe ${itemName}`, e)
+      throw e
+    }
+  }
+
+  private unsubscribe = async (
+    connectionContext: RpcConnectionContext,
+    itemName: string,
+    parameters: unknown[]
+  ) => {
+    try {
+      this.localSubscriptions.unsubscribe(connectionContext.clientId, itemName, parameters)
+    } catch (e) {
+      log.error(`Failed to unsubscribe ${itemName}`, e)
+      throw e
+    }
+  }
+
+  private getRemoteFunction(
+    itemName: string,
+    root: any = this.services
+  ): {function: RemoteFunction; container: any} | undefined {
+    const parts = itemName.split("/")
+
+    let item = root
+    let parent
+
+    for (const part of parts) {
+      if (!item) return undefined
+
+      parent = item
+      item = item[part]
+    }
+
+    if (!item) return undefined
+
+    return {
+      function: item,
+      container: parent,
+    }
+  }
+
+  private invokeLocalFunction(
+    connectionContext: RpcConnectionContext,
+    itemName: string,
+    item: {function: RemoteFunction; container: any},
+    parameters: unknown[],
+    invocationType: InvocationType
+  ): Promise<unknown> {
+    return this.invocationCache.invoke(
+      {clientId: connectionContext.clientId, itemName, parameters},
+      () => {
+        const parametersCopy: unknown[] = safeParseJson(safeStringify(parameters))
+
+        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)
+      }
+    )
+  }
+}

package/src/server/http.ts

@@ -0,0 +1,109 @@
+import * as http from "http"
+import {IncomingMessage, ServerResponse} from "http"
+import {RpcConnectionContext} from "../rpc.js"
+import {safeParseJson, safeStringify} from "../utils/json.js"
+import {log} from "../logger.js"
+
+export async function serveHttpRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  path: string,
+  hooks: HttpServerHooks,
+  createConnectionContext: (req: IncomingMessage) => Promise<RpcConnectionContext>
+) {
+  // if port is in options - response 404 on other URLs
+  // oherwise just handle request
+
+  if (req.url?.startsWith(path)) {
+    try {
+      const ctx = await createConnectionContext(req)
+
+      const itemName = req.url.slice(path.length + 1)
+
+      const isJson = req.headersDistinct["content-type"]?.includes("application/json") ?? false
+      const body = isJson ? safeParseJson(await readBody(req)) : []
+
+      let result: unknown
+      switch (req.method) {
+        case "POST":
+          result = await hooks.call(ctx, itemName, body)
+          break
+        case "PUT":
+          result = await hooks.subscribe(ctx, itemName, body)
+          break
+        case "PATCH":
+          result = await hooks.unsubscribe(ctx, itemName, body)
+          break
+        default:
+          res.statusCode = 404
+          res.end()
+          return
+      }
+
+      if (typeof result == "undefined") {
+        res.statusCode = 204
+        res.end()
+        return
+      }
+
+      if (typeof result == "string") {
+        res.setHeader("Content-Type", "text/plain")
+        res.write(result)
+        res.end()
+        return
+      }
+
+      res.setHeader("Content-Type", "application/json")
+      res.write(safeStringify(result))
+      res.end()
+    } catch (e: any) {
+      if (e.code) {
+        res.statusCode = e.code
+        res.statusMessage = e.message
+        const {code, message, stack, ...rest} = e
+        if (Object.keys(rest).length > 0) {
+          res.setHeader("Content-Type", "application/json")
+          res.write(safeStringify(rest))
+        }
+        res.end()
+        return
+      } else {
+        log.warn(`Error in ${req.url}.`, e)
+
+        res.statusCode = 500
+        res.statusMessage = e["message"] || "Internal Server Error"
+        res.end()
+        return
+      }
+    }
+  }
+}
+
+function readBody(req: http.IncomingMessage) {
+  return new Promise<string>((resolve, reject) => {
+    let body = ""
+    req.on("data", (chunk: Buffer) => {
+      body += chunk.toString()
+    })
+    req.on("end", () => {
+      resolve(body)
+    })
+    req.on("error", (error: any) => {
+      reject(error)
+    })
+  })
+}
+
+export type HttpServerHooks = {
+  call(ctx: RpcConnectionContext, itemName: string, parameters: unknown[]): Promise<unknown>
+  subscribe(
+    clientId: RpcConnectionContext,
+    itemName: string,
+    parameters: unknown[]
+  ): Promise<unknown>
+  unsubscribe(
+    clientId: RpcConnectionContext,
+    itemName: string,
+    parameters: unknown[]
+  ): Promise<unknown>
+}

package/src/server/index.ts

@@ -0,0 +1,65 @@
+import {CLIENT_ID_HEADER, RpcConnectionContext, RpcContext, Services} from "../rpc.js"
+import {ServicesWithTriggers} from "./local.js"
+import {Middleware} from "../utils/middleware.js"
+import {RpcServerImpl} from "./RpcServerImpl.js"
+import http, {IncomingMessage} from "http"
+
+export async function publishServices<S extends Services<S>, C extends RpcContext>(
+  services: S,
+  overrideOptions: Partial<PublishServicesOptions<C>> & ({port: number} | {server: http.Server})
+): Promise<{
+  server: RpcServer
+  services: ServicesWithTriggers<S>
+  httpServer: http.Server
+}> {
+  const options = {
+    ...defaultOptions,
+    ...overrideOptions,
+  }
+
+  const rpcServer = new RpcServerImpl<S, C>(services, options)
+
+  await rpcServer.start()
+
+  return {
+    services: rpcServer.createServicesWithTriggers(),
+    server: rpcServer,
+    httpServer: rpcServer.httpServer,
+  }
+}
+
+export type RpcServer = {
+  close(): Promise<void>
+  // test-only
+  _allSubscriptions(): Array<any[]>
+}
+
+export type PublishServicesOptions<C extends RpcContext> = {
+  host: string
+
+  path: string
+  middleware: Middleware<C>[]
+  pingInterval: number
+  createConnectionContext(req: IncomingMessage): Promise<RpcConnectionContext>
+} & (
+  | {
+      server: http.Server
+    }
+  | {
+      port: number
+    }
+  | {}
+)
+
+const defaultOptions: Omit<PublishServicesOptions<RpcContext>, "port"> = {
+  path: "",
+  host: "0.0.0.0",
+  middleware: [],
+  pingInterval: 30 * 1000, // should be in-sync with client
+
+  async createConnectionContext(req: IncomingMessage): Promise<RpcConnectionContext> {
+    return {
+      clientId: req.headersDistinct[CLIENT_ID_HEADER]?.[0] || "anon",
+    }
+  },
+}