@push-rpc/next 2.0.24 → 2.0.26

package/dist/server/implementation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation.js","sourceRoot":"","sources":["../../src/server/implementation.ts"],"names":[],"mappings":"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"}

package/dist/server/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { RpcConnectionContext, RpcContext, Services } from "../rpc.js";
-import { ServicesWithTriggers } from "./local.js";
+import { ServicesImplementation } from "./implementation.js";
 import { Middleware } from "../utils/middleware.js";
 import http, { IncomingMessage, ServerResponse } from "http";
 import { HttpServerHooks } from "./http";
@@ -10,7 +10,7 @@ export declare function publishServices<S extends Services<S>, C extends RpcCont
     server: http.Server;
 })): Promise<{
     server: RpcServer;
-    services: ServicesWithTriggers<S>;
+    services: ServicesImplementation<S>;
     httpServer: http.Server;
 }>;
 export type RpcServer = {

package/dist/server/index.js

@@ -11,7 +11,7 @@ async function publishServices(services, overrideOptions) {
     const rpcServer = new RpcServerImpl_js_1.RpcServerImpl(services, options);
     await rpcServer.start();
     return {
-        services: rpcServer.createServicesWithTriggers(),
+        services: rpcServer.implementation,
         server: rpcServer,
         httpServer: rpcServer.httpServer,
     };

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.24",
+  "version": "2.0.26",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/client/HttpClient.ts

@@ -63,7 +63,11 @@ export class HttpClient {
         contentType && contentType.includes("application/json") ? safeParseJson(text) : text
 
       if (hasError || response.status < 200 || response.status >= 300) {
-        const error = new Error(response.headers.get("x-error") ?? undefined)
+        const error = new Error(
+          !!response.headers.get("x-error")
+            ? decodeURIComponent(response.headers.get("x-error")!!)
+            : undefined,
+        )
 
         Object.assign(error, {code: response.status})
 

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 {
@@ -70,7 +70,7 @@ export async function serveHttpRequest(
       if (e.code && typeof e.code == "number" && e.code >= 100 && e.code < 600) {
         res.statusCode = e.code
 
-        res.setHeader("X-Error", e["message"] ?? "")
+        res.setHeader("X-Error", encodeURIComponent(e["message"] ?? ""))
         const {code, message, stack, ...rest} = e
         if (Object.keys(rest).length > 0) {
           res.setHeader("Content-Type", "application/json")
@@ -83,7 +83,7 @@ export async function serveHttpRequest(
 
         res.statusCode = 500
         if (e["message"]) {
-          res.setHeader("X-Error", e["message"])
+          res.setHeader("X-Error", encodeURIComponent(e["message"]))
         }
         res.end()
         return

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 {