@push-rpc/next 2.0.25 → 3.0.0

package/dist/server/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":";;;AAAA,sCAAsF;AAGtF,yDAAgD;AAIzC,KAAK,UAAU,eAAe,CACnC,QAAW,EACX,eAA8F;IAM9F,MAAM,OAAO,GAAG;QACd,GAAG,cAAc;QACjB,GAAG,eAAe;KACnB,CAAA;IAED,MAAM,SAAS,GAAG,IAAI,gCAAa,CAAO,QAAQ,EAAE,OAAO,CAAC,CAAA;IAE5D,MAAM,SAAS,CAAC,KAAK,EAAE,CAAA;IAEvB,OAAO;QACL,QAAQ,EAAE,SAAS,CAAC,0BAA0B,EAAE;QAChD,MAAM,EAAE,SAAS;QACjB,UAAU,EAAE,SAAS,CAAC,UAAU;KACjC,CAAA;AACH,CAAC;AAtBD,0CAsBC;AA0BD,MAAM,cAAc,GAAqD;IACvE,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,SAAS;IACf,UAAU,EAAE,EAAE;IACd,YAAY,EAAE,EAAE,GAAG,IAAI,EAAE,gCAAgC;IACzD,aAAa,EAAE,IAAI;IAEnB,KAAK,CAAC,uBAAuB,CAAC,GAAoB,EAAE,GAAmB;QACrE,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,yBAAgB,CAAC,CAAA;QAE5C,OAAO;YACL,QAAQ,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,MAAM;SACjE,CAAA;IACH,CAAC;CACF,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":";;;AAAA,sCAAsF;AAGtF,yDAAgD;AAIzC,KAAK,UAAU,eAAe,CACnC,QAAW,EACX,eAA8F;IAM9F,MAAM,OAAO,GAAG;QACd,GAAG,cAAc;QACjB,GAAG,eAAe;KACnB,CAAA;IAED,MAAM,SAAS,GAAG,IAAI,gCAAa,CAAO,QAAQ,EAAE,OAAO,CAAC,CAAA;IAE5D,MAAM,SAAS,CAAC,KAAK,EAAE,CAAA;IAEvB,OAAO;QACL,QAAQ,EAAE,SAAS,CAAC,cAAc;QAClC,MAAM,EAAE,SAAS;QACjB,UAAU,EAAE,SAAS,CAAC,UAAU;KACjC,CAAA;AACH,CAAC;AAtBD,0CAsBC;AA0BD,MAAM,cAAc,GAAqD;IACvE,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,SAAS;IACf,UAAU,EAAE,EAAE;IACd,YAAY,EAAE,EAAE,GAAG,IAAI,EAAE,gCAAgC;IACzD,aAAa,EAAE,IAAI;IAEnB,KAAK,CAAC,uBAAuB,CAC3B,GAAoB,EACpB,GAAmB;QAEnB,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,yBAAgB,CAAC,CAAA;QAE5C,OAAO;YACL,QAAQ,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,MAAM;SACjE,CAAA;IACH,CAAC;CACF,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push-rpc/next",
-  "version": "2.0.25",
+  "version": "3.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/client/RpcClientImpl.ts

@@ -3,7 +3,7 @@ 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 {createRemote, ServicesClient} from "./remote.js"
 import {ConsumeServicesOptions, RpcClient} from "./index.js"
 import {withMiddlewares} from "../utils/middleware.js"
 
@@ -86,7 +86,7 @@ export class RpcClientImpl<S extends Services<S>> implements RpcClient {
     return this.connection._webSocket()
   }
 
-  createRemote(): ServicesWithSubscriptions<S> {
+  createRemote(): ServicesClient<S> {
     return createRemote<S>({
       call: this.call,
       subscribe: this.subscribe,

package/src/client/index.ts

@@ -1,5 +1,5 @@
 import {RpcContext, Services} from "../rpc.js"
-import {ServicesWithSubscriptions} from "./remote.js"
+import {ServicesClient} from "./remote.js"
 import {RpcClientImpl} from "./RpcClientImpl.js"
 import {Middleware} from "../utils/middleware.js"
 
@@ -41,7 +41,7 @@ export async function consumeServices<S extends Services<S>>(
   overrideOptions: Partial<ConsumeServicesOptions> = {},
 ): Promise<{
   client: RpcClient
-  remote: ServicesWithSubscriptions<S>
+  remote: ServicesClient<S>
 }> {
   if (url.endsWith("/")) {
     throw new Error("URL must not end with /")
@@ -73,10 +73,8 @@ const defaultOptions: ConsumeServicesOptions = {
   middleware: [],
   notificationsMiddleware: [],
   connectOnCreate: false,
-  onConnected: () => {
-  },
-  onDisconnected: () => {
-  },
+  onConnected: () => {},
+  onDisconnected: () => {},
   getHeaders: async () => ({}),
 
   getSubscriptionsUrl(url: string): string {

package/src/client/remote.ts

@@ -3,7 +3,7 @@ import {CallOptions, Consumer, RemoteFunction, Services} from "../rpc.js"
 export function createRemote<S extends Services<S>>(
   hooks: RemoteHooks,
   name = "",
-): ServicesWithSubscriptions<S> {
+): ServicesClient<S> {
   // start with remote function
   const remoteItem = (...paramsWithCallOptions: unknown[]) => {
     const {params, callOptions} = extractCallOptions(paramsWithCallOptions)
@@ -99,20 +99,17 @@ export type AddParameters<
   TParameters extends [...args: any],
 > = (...args: [...Parameters<TFunction>, ...TParameters]) => ReturnType<TFunction>
 
-export type ServicesWithSubscriptions<T extends Services<T>> = {
+export type FunctionClient<F extends RemoteFunction> = {
+  subscribe(consumer: Consumer<F>, ...parameters: [...Parameters<F>, CallOptions?]): Promise<void>
+  unsubscribe(consumer: Consumer<F>, ...parameters: [...Parameters<F>, CallOptions?]): Promise<void>
+  itemName: string
+}
+
+export type ServicesClient<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>
-  }
+    ? AddParameters<T[K], [CallOptions?]> & FunctionClient<T[K]>
     : T[K] extends object
-      ? ServicesWithSubscriptions<T[K]>
+      ? ServicesClient<T[K]>
       : never
 }
 

package/src/index.ts

@@ -1,4 +1,11 @@
-export type {RemoteFunction, Services, Consumer, RpcContext, RpcConnectionContext} from "./rpc.js"
+import {ServicesClient} from "./client/remote"
+
+import type {Services} from "./rpc.js"
+import type {ServicesImplementation} from "./server/implementation.js"
+
+export {Services}
+
+export type {RemoteFunction, Consumer, RpcContext, RpcConnectionContext} from "./rpc.js"
 export {RpcError, RpcErrors, CallOptions} from "./rpc.js"
 
 export type {Middleware} from "./utils/middleware.js"
@@ -8,12 +15,22 @@ export type {RpcServer, PublishServicesOptions} from "./server/index.js"
 export type {HttpServerHooks} from "./server/http.js"
 export {publishServices} from "./server/index.js"
 
-export type {ServicesWithTriggers} from "./server/local.js"
+export type {
+  FunctionImplementation,
+  ThrottleSettings,
+  SubscribeEvent,
+  UnsubscribeEvent,
+} from "./server/implementation.js"
+
+export {ServicesImplementation}
 
 export type {RpcClient, ConsumeServicesOptions, ClientCache} from "./client/index.js"
 export {consumeServices} from "./client/index.js"
 
-export type {ServicesWithSubscriptions} from "./client/remote.js"
+export type {ServicesClient, FunctionClient, AddParameters} from "./client/remote.js"
 
 export {log, setLogger} from "./logger.js"
 export {safeStringify, safeParseJson} from "./utils/json.js"
+export type {ExtractPromiseResult} from "./utils/types.js"
+
+export type UnifiedServices<T extends Services<T>> = ServicesImplementation<T> & ServicesClient<T>

package/src/server/RpcServerImpl.ts

@@ -1,5 +1,5 @@
 import {PublishServicesOptions, RpcServer} from "./index.js"
-import {LocalSubscriptions} from "./LocalSubscriptions.js"
+import {ServerSubscriptions} from "./ServerSubscriptions.js"
 import http from "http"
 import type {ConnectionsServer} from "./ConnectionsServer.js"
 import {serveHttpRequest} from "./http.js"
@@ -14,14 +14,21 @@ import {
 } from "../rpc.js"
 import {log} from "../logger.js"
 import {withMiddlewares} from "../utils/middleware.js"
-import {ServicesWithTriggers, withTriggers} from "./local.js"
+import {
+  eventEmitterSymbol,
+  prepareImplementation,
+  ServicesImplementation,
+} from "./implementation.js"
 import {safeParseJson, safeStringify} from "../utils/json.js"
+import EventEmitter from "node:events"
 
 export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implements RpcServer {
   constructor(
     private readonly services: S,
     private readonly options: PublishServicesOptions<C>,
   ) {
+    this.implementation = prepareImplementation(this.localSubscriptions, services)
+
     if ("server" in this.options) {
       this.httpServer = this.options.server
     } else {
@@ -63,7 +70,19 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
       this.httpServer,
       {pingInterval: this.options.pingInterval, path: this.options.path},
       (clientId) => {
-        this.localSubscriptions.unsubscribeAll(clientId)
+        const unsubscribed = this.localSubscriptions.unsubscribeAll(clientId)
+
+        for (const {itemName, parameters, clientId} of unsubscribed) {
+          const item = this.getRemoteFunction(itemName)
+
+          if (item) {
+            item.eventEmitter.emit("unsubscribe", {
+              itemName,
+              filter: parameters[0],
+              clientId,
+            })
+          }
+        }
       },
       !("server" in this.options),
     )
@@ -104,17 +123,15 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
     })
   }
 
-  createServicesWithTriggers(): ServicesWithTriggers<S> {
-    return withTriggers(this.localSubscriptions, this.services)
-  }
-
   _allSubscriptions() {
     return this.localSubscriptions._allSubscriptions()
   }
 
-  private readonly localSubscriptions = new LocalSubscriptions()
+  private readonly localSubscriptions = new ServerSubscriptions()
   private connectionsServer: ConnectionsServer | null = null
-  readonly httpServer
+
+  public readonly httpServer: http.Server
+  public readonly implementation: ServicesImplementation<S>
 
   private call = async (
     connectionContext: RpcConnectionContext,
@@ -187,7 +204,21 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
       })
 
       if (this.connectionsServer?.isClientSubscribed(connectionContext.clientId)) {
-        this.localSubscriptions.subscribe(connectionContext.clientId, itemName, parameters, update)
+        const subscriptionAdded = this.localSubscriptions.subscribe(
+          connectionContext.clientId,
+          itemName,
+          parameters,
+          update,
+        )
+
+        if (subscriptionAdded) {
+          item.eventEmitter.emit("subscribe", {
+            itemName,
+            filter: parameters[0],
+            clientId: connectionContext.clientId,
+            context: connectionContext,
+          })
+        }
       }
 
       const lastData = await this.invokeLocalFunction(
@@ -201,7 +232,19 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
 
       return lastData
     } catch (e) {
-      this.localSubscriptions.unsubscribe(connectionContext.clientId, itemName, parameters)
+      const unsubscribed = this.localSubscriptions.unsubscribe(
+        connectionContext.clientId,
+        itemName,
+        parameters,
+      )
+
+      if (unsubscribed) {
+        item.eventEmitter.emit("subscribe", {
+          itemName,
+          filter: parameters[0],
+          clientId: connectionContext.clientId,
+        })
+      }
 
       log.error(`Failed to subscribe ${itemName}`, e)
       throw e
@@ -214,17 +257,34 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
     parameters: unknown[],
   ) => {
     try {
-      this.localSubscriptions.unsubscribe(connectionContext.clientId, itemName, parameters)
+      const unsubscribed = this.localSubscriptions.unsubscribe(
+        connectionContext.clientId,
+        itemName,
+        parameters,
+      )
+      if (unsubscribed) {
+        const item = this.getRemoteFunction(itemName)
+
+        if (item) {
+          item.eventEmitter.emit("unsubscribe", {
+            itemName,
+            filter: parameters[0],
+            clientId: connectionContext.clientId,
+          })
+        }
+      }
     } catch (e) {
       log.error(`Failed to unsubscribe ${itemName}`, e)
       throw e
     }
   }
 
+  // getRemoteFunction should only take functions from services, and not from implementation in
+  // order to not take .trigger and other implementation-specific details
   private getRemoteFunction(
     itemName: string,
     root: any = this.services,
-  ): {function: RemoteFunction; container: any} | undefined {
+  ): {function: RemoteFunction; eventEmitter: EventEmitter; container: any} | undefined {
     const parts = itemName.split("/")
 
     let item = root
@@ -239,8 +299,11 @@ export class RpcServerImpl<S extends Services<S>, C extends RpcContext> implemen
 
     if (!item) return undefined
 
+    item[eventEmitterSymbol] = item[eventEmitterSymbol] ?? new EventEmitter()
+
     return {
       function: item,
+      eventEmitter: item[eventEmitterSymbol],
       container: parent,
     }
   }

package/src/server/{LocalSubscriptions.ts → ServerSubscriptions.ts}

@@ -1,14 +1,14 @@
 import {safeStringify} from "../utils/json.js"
 import {lastValueReducer, throttle} from "../utils/throttle.js"
-import {ThrottleSettings} from "./local.js"
+import {ThrottleSettings} from "./implementation.js"
 
-export class LocalSubscriptions {
+export class ServerSubscriptions {
   subscribe(
     clientId: string,
     itemName: string,
     parameters: unknown[],
     update: (suppliedData?: unknown) => void,
-  ) {
+  ): boolean {
     const itemSubscriptions = this.byItem.get(itemName) || {byFilter: new Map()}
     this.byItem.set(itemName, itemSubscriptions)
 
@@ -22,22 +22,30 @@ export class LocalSubscriptions {
 
     if (!subscriptions.subscribedClients.some((c) => c.clientId == clientId)) {
       subscriptions.subscribedClients.push({clientId, update})
+
+      return true
     }
+
+    return false
   }
 
-  unsubscribe(clientId: string, itemName: string, parameters: unknown[]) {
+  unsubscribe(clientId: string, itemName: string, parameters: unknown[]): boolean {
     const itemSubscriptions = this.byItem.get(itemName)
-    if (!itemSubscriptions) return
+    if (!itemSubscriptions) return false
 
     const filterKey = getFilterKey(parameters)
 
     const subscriptions = itemSubscriptions.byFilter.get(filterKey)
-    if (!subscriptions) return
+    if (!subscriptions) return false
+
+    const oldLength = subscriptions.subscribedClients.length
 
     subscriptions.subscribedClients = subscriptions.subscribedClients.filter(
       (subscription) => subscription.clientId != clientId,
     )
 
+    const unsubscribed = oldLength != subscriptions.subscribedClients.length
+
     if (!subscriptions.subscribedClients.length) {
       itemSubscriptions.byFilter.delete(filterKey)
 
@@ -45,14 +53,28 @@ export class LocalSubscriptions {
         this.byItem.delete(itemName)
       }
     }
+
+    return unsubscribed
   }
 
-  unsubscribeAll(clientId: string) {
+  unsubscribeAll(clientId: string): Subscribed[] {
+    const r: Subscribed[] = []
+
     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,
-        )
+        subscriptions.subscribedClients = subscriptions.subscribedClients.filter((subscription) => {
+          const evict = subscription.clientId == clientId
+
+          if (evict) {
+            r.push({
+              itemName,
+              parameters: [subscriptions.filter],
+              clientId: clientId,
+            })
+          }
+
+          return !evict
+        })
 
         if (!subscriptions.subscribedClients.length) {
           itemSubscriptions.byFilter.delete(filterKey)
@@ -63,6 +85,8 @@ export class LocalSubscriptions {
         this.byItem.delete(itemName)
       }
     }
+
+    return r
   }
 
   trigger(itemName: string, triggerFilter: Record<string, unknown> = {}, suppliedData?: unknown) {
@@ -153,3 +177,9 @@ function filterContains(
 function getFilterKey(parameters: unknown[]) {
   return safeStringify(parameters?.[0] ?? null)
 }
+
+type Subscribed = {
+  itemName: string
+  parameters: unknown[]
+  clientId: string
+}

package/src/server/http.ts

@@ -16,7 +16,7 @@ export async function serveHttpRequest(
   ) => Promise<RpcConnectionContext>,
 ) {
   // if port is in options - response 404 on other URLs
-  // oherwise just handle request
+  // otherwise simply handle request
 
   if (req.url?.startsWith(path)) {
     try {

package/src/server/implementation.ts

@@ -0,0 +1,116 @@
+import {RemoteFunction, RpcConnectionContext, Services} from "../rpc.js"
+import {ServerSubscriptions} from "./ServerSubscriptions"
+import {ExtractPromiseResult} from "../utils/types.js"
+import {ThrottleArgsReducer} from "../utils/throttle.js"
+import EventEmitter from "node:events"
+
+export const eventEmitterSymbol = Symbol("eventEmitter")
+
+export type ThrottleSettings<D> = {
+  timeout: number
+  reducer?: ThrottleArgsReducer<D>
+}
+
+export function prepareImplementation<T extends Services<T>>(
+  serverSubscriptions: ServerSubscriptions,
+  services: T,
+  name = "",
+): ServicesImplementation<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)
+        }
+
+        // bind eventEmitter to source services, so it can be looked up from getRemoteFunction
+        target[propName][eventEmitterSymbol] =
+          target[propName][eventEmitterSymbol] ?? new EventEmitter()
+
+        delegate.trigger = (filter: Record<string, unknown> = {}, suppliedData?: unknown) => {
+          // triggers are delayed for consumers to receive updates after the current call ends.
+          setTimeout(() => {
+            serverSubscriptions.trigger(itemName, filter, suppliedData)
+          }, 0)
+        }
+
+        delegate.throttle = (settings: ThrottleSettings<unknown>) => {
+          serverSubscriptions.throttleItem(itemName, settings)
+        }
+
+        delegate.addEventListener = (eventName: string, listener: (event: unknown) => void) => {
+          target[propName][eventEmitterSymbol].addListener(eventName, listener)
+        }
+
+        delegate.removeEventListener = (eventName: string, listener: (event: unknown) => void) => {
+          target[propName][eventEmitterSymbol].removeListener(eventName, listener)
+        }
+
+        return delegate
+      } else if (!cachedItems[propName]) {
+        cachedItems[propName] = prepareImplementation(
+          serverSubscriptions,
+          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 SubscribeEvent<F extends RemoteFunction> = {
+  itemName: string
+  filter: Parameters<F>[0]
+  clientId: string
+  context: RpcConnectionContext
+}
+
+// UnsubscribeEVent cannot contain ctx b/c ctx won't be available in case of disconnecting entire client
+export type UnsubscribeEvent<F extends RemoteFunction> = {
+  itemName: string
+  filter: Parameters<F>[0]
+  clientId: string
+}
+
+export type FunctionImplementation<F extends RemoteFunction> = {
+  trigger(
+    filter?: Partial<Parameters<F>[0]>,
+    suppliedData?: ExtractPromiseResult<ReturnType<F>>,
+  ): void
+  throttle(settings: ThrottleSettings<ExtractPromiseResult<ReturnType<F>>>): void
+
+  addEventListener(event: "subscribe", listener: (event: SubscribeEvent<F>) => void): void
+  addEventListener(event: "unsubscribe", listener: (event: UnsubscribeEvent<F>) => void): void
+  removeEventListener(event: "subscribe", listener: (event: SubscribeEvent<F>) => void): void
+  removeEventListener(event: "unsubscribe", listener: (event: UnsubscribeEvent<F>) => void): void
+}
+
+export type ServicesImplementation<T extends Services<T>> = {
+  [K in keyof T]: T[K] extends RemoteFunction
+    ? T[K] & FunctionImplementation<T[K]>
+    : T[K] extends object
+      ? ServicesImplementation<T[K]>
+      : never
+}

package/src/server/index.ts

@@ -1,5 +1,5 @@
 import {CLIENT_ID_HEADER, RpcConnectionContext, RpcContext, Services} from "../rpc.js"
-import {ServicesWithTriggers} from "./local.js"
+import {ServicesImplementation} from "./implementation.js"
 import {Middleware} from "../utils/middleware.js"
 import {RpcServerImpl} from "./RpcServerImpl.js"
 import http, {IncomingMessage, ServerResponse} from "http"
@@ -10,7 +10,7 @@ export async function publishServices<S extends Services<S>, C extends RpcContex
   overrideOptions: Partial<PublishServicesOptions<C>> & ({port: number} | {server: http.Server}),
 ): Promise<{
   server: RpcServer
-  services: ServicesWithTriggers<S>
+  services: ServicesImplementation<S>
   httpServer: http.Server
 }> {
   const options = {
@@ -23,7 +23,7 @@ export async function publishServices<S extends Services<S>, C extends RpcContex
   await rpcServer.start()
 
   return {
-    services: rpcServer.createServicesWithTriggers(),
+    services: rpcServer.implementation,
     server: rpcServer,
     httpServer: rpcServer.httpServer,
   }
@@ -45,13 +45,13 @@ export type PublishServicesOptions<C extends RpcContext> = {
   createServerHooks?(hooks: HttpServerHooks, req: IncomingMessage): HttpServerHooks
 } & (
   | {
-  server: http.Server
-}
+      server: http.Server
+    }
   | {
-  port: number
-}
+      port: number
+    }
   | {}
-  )
+)
 
 const defaultOptions: Omit<PublishServicesOptions<RpcContext>, "port"> = {
   path: "",
@@ -60,7 +60,10 @@ const defaultOptions: Omit<PublishServicesOptions<RpcContext>, "port"> = {
   pingInterval: 30 * 1000, // should be in-sync with client
   subscriptions: true,
 
-  async createConnectionContext(req: IncomingMessage, res: ServerResponse): Promise<RpcConnectionContext> {
+  async createConnectionContext(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): Promise<RpcConnectionContext> {
     const header = req.headers[CLIENT_ID_HEADER]
 
     return {

package/tests/events.ts

@@ -0,0 +1,82 @@
+import {createTestClient, startTestServer, testClient} from "./testUtils.js"
+import {assert} from "chai"
+import {adelay} from "../src/utils/promises.js"
+
+describe("Events", () => {
+  it("subscribe event", async () => {
+    const services = await startTestServer({
+      test: {
+        item: async (a: string) => {},
+      },
+    })
+
+    let event
+    services.test.item.addEventListener("subscribe", (e) => {
+      event = e
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    await client.test.item.subscribe(() => {}, "a")
+
+    assert.deepEqual(event, {
+      itemName: "test/item",
+      filter: "a",
+      clientId: testClient!.clientId,
+      context: {
+        clientId: testClient!.clientId,
+      },
+    })
+  })
+  it("unsubscribe event", async () => {
+    const services = await startTestServer({
+      test: {
+        item: async (a: string) => {},
+      },
+    })
+
+    let event
+    services.test.item.addEventListener("unsubscribe", (e) => {
+      event = e
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const listener = () => {}
+    await client.test.item.subscribe(listener, "a")
+    await client.test.item.unsubscribe(listener, "a")
+
+    assert.deepEqual(event, {
+      itemName: "test/item",
+      filter: "a",
+      clientId: testClient!.clientId,
+    })
+  })
+  it("unsubscribe on disconnect WS", async () => {
+    const services = await startTestServer({
+      test: {
+        item: async (a: string) => {},
+      },
+    })
+
+    let event
+    services.test.item.addEventListener("unsubscribe", (e) => {
+      event = e
+    })
+
+    const client = await createTestClient<typeof services>()
+
+    const listener = () => {}
+    await client.test.item.subscribe(listener, "a")
+
+    await testClient!.close()
+
+    await adelay(100)
+
+    assert.deepEqual(event, {
+      itemName: "test/item",
+      filter: "a",
+      clientId: testClient!.clientId,
+    })
+  })
+})