@cybermp/rpc-server 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CyberMP-RPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+const rpcCore = require('@cybermp/rpc-core');
+const definitions = require('@cybermp/rpc-core/definitions');
+const utils = require('@cybermp/rpc-core/utils');
+
+class RpcServerContext extends definitions.RpcContext {
+  player;
+  constructor(options, player) {
+    super(options);
+    this.player = player;
+  }
+}
+
+class RpcServerDatabus extends rpcCore.RpcDatabus {
+  constructor(options) {
+    super(options);
+    this.setupListeners();
+  }
+  setupListeners() {
+    mp.events.onClient(this.RPC_INVOKE_EVENT, (player, packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), player);
+    });
+    mp.events.onClient(this.RPC_RESPONSE_EVENT, (player, packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), player);
+    });
+  }
+  send(packet, player) {
+    if (!player) {
+      return;
+    }
+    const eventNamesMap = {
+      [definitions.RpcPacketType.CALL]: this.RPC_INVOKE_EVENT,
+      [definitions.RpcPacketType.TRIGGER]: this.RPC_INVOKE_EVENT,
+      [definitions.RpcPacketType.RESPONSE]: this.RPC_RESPONSE_EVENT
+    };
+    const eventName = eventNamesMap[packet.type];
+    if (!eventName) {
+      return;
+    }
+    mp.events.emitClient(player, eventName, this.serialize(packet));
+  }
+}
+
+class RpcServer extends rpcCore.RpcBase {
+  databus;
+  constructor(options = {}) {
+    super(options);
+    this.databus = new RpcServerDatabus(this.options);
+    this.init();
+  }
+  async internalCall(packet, options, player) {
+    return new Promise((resolve, reject) => {
+      this.pendingStore.addPending({
+        resolve,
+        reject,
+        packet,
+        ...options
+      });
+      this.databus.send(packet, player);
+    });
+  }
+  internalTrigger(packet, player) {
+    this.databus.send(packet, player);
+  }
+  createContext(packet, player) {
+    return new RpcServerContext(
+      {
+        data: packet.data,
+        meta: packet.meta,
+        packet
+      },
+      player
+    );
+  }
+  forward() {
+    console.error("Forwarding packets in server is unsupported");
+  }
+  callClient(player, method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.CLIENT }
+    );
+    return this.call(packet, options, player);
+  }
+  triggerClient(player, method, data, meta) {
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.CLIENT }
+    );
+    this.trigger(packet, player);
+  }
+  callBrowser(player, method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.BROWSER }
+    );
+    return this.call(packet, options, player);
+  }
+  triggerBrowser(player, method, data, meta) {
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.BROWSER }
+    );
+    this.trigger(packet, player);
+  }
+}
+
+exports.RpcOptions = rpcCore.RpcOptions;
+exports.RpcServer = RpcServer;
+exports.RpcServerContext = RpcServerContext;
+Object.prototype.hasOwnProperty.call(definitions, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: definitions['__proto__']
+  });
+
+Object.keys(definitions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = definitions[k];
+});
+Object.prototype.hasOwnProperty.call(utils, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: utils['__proto__']
+  });
+
+Object.keys(utils).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = utils[k];
+});

package/dist/index.d.cts

@@ -0,0 +1,33 @@
+import { RpcDatabus, RpcOptions, RpcBase, CallOptions, CallConfig } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcContextConstructor, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+declare class RpcServerContext<D = any, M extends Record<string, any> = Record<string, any>> extends RpcContext<D, M> {
+    player: MpPlayer;
+    constructor(options: RpcContextConstructor<D, M>, player: MpPlayer);
+}
+
+declare class RpcServerDatabus extends RpcDatabus {
+    constructor(options: RpcOptions);
+    private setupListeners;
+    send(packet: RpcPacket, player: MpPlayer | number): void;
+}
+
+declare class RpcServer extends RpcBase<RpcServerContext> {
+    protected databus: RpcServerDatabus;
+    constructor(options?: Partial<RpcOptions>);
+    protected internalCall<R>(packet: RpcPacket, options: CallOptions, player: MpPlayer | number): Promise<R>;
+    protected internalTrigger(packet: RpcPacket, player: MpPlayer | number): void;
+    protected createContext(packet: RpcPacket, player: MpPlayer): RpcServerContext;
+    protected forward(): void;
+    callClient<R = any>(player: MpPlayer | number, method: string, options?: CallConfig): Promise<R>;
+    callClient<R = any>(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerClient(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>): void;
+    callBrowser<R = any>(player: MpPlayer | number, method: string, options?: CallConfig): Promise<R>;
+    callBrowser<R = any>(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerBrowser(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>): void;
+}
+
+export { RpcServer, RpcServerContext };

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+import { RpcDatabus, RpcOptions, RpcBase, CallOptions, CallConfig } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcContextConstructor, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+declare class RpcServerContext<D = any, M extends Record<string, any> = Record<string, any>> extends RpcContext<D, M> {
+    player: MpPlayer;
+    constructor(options: RpcContextConstructor<D, M>, player: MpPlayer);
+}
+
+declare class RpcServerDatabus extends RpcDatabus {
+    constructor(options: RpcOptions);
+    private setupListeners;
+    send(packet: RpcPacket, player: MpPlayer | number): void;
+}
+
+declare class RpcServer extends RpcBase<RpcServerContext> {
+    protected databus: RpcServerDatabus;
+    constructor(options?: Partial<RpcOptions>);
+    protected internalCall<R>(packet: RpcPacket, options: CallOptions, player: MpPlayer | number): Promise<R>;
+    protected internalTrigger(packet: RpcPacket, player: MpPlayer | number): void;
+    protected createContext(packet: RpcPacket, player: MpPlayer): RpcServerContext;
+    protected forward(): void;
+    callClient<R = any>(player: MpPlayer | number, method: string, options?: CallConfig): Promise<R>;
+    callClient<R = any>(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerClient(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>): void;
+    callBrowser<R = any>(player: MpPlayer | number, method: string, options?: CallConfig): Promise<R>;
+    callBrowser<R = any>(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerBrowser(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>): void;
+}
+
+export { RpcServer, RpcServerContext };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { RpcDatabus, RpcOptions, RpcBase, CallOptions, CallConfig } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcContextConstructor, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+declare class RpcServerContext<D = any, M extends Record<string, any> = Record<string, any>> extends RpcContext<D, M> {
+    player: MpPlayer;
+    constructor(options: RpcContextConstructor<D, M>, player: MpPlayer);
+}
+
+declare class RpcServerDatabus extends RpcDatabus {
+    constructor(options: RpcOptions);
+    private setupListeners;
+    send(packet: RpcPacket, player: MpPlayer | number): void;
+}
+
+declare class RpcServer extends RpcBase<RpcServerContext> {
+    protected databus: RpcServerDatabus;
+    constructor(options?: Partial<RpcOptions>);
+    protected internalCall<R>(packet: RpcPacket, options: CallOptions, player: MpPlayer | number): Promise<R>;
+    protected internalTrigger(packet: RpcPacket, player: MpPlayer | number): void;
+    protected createContext(packet: RpcPacket, player: MpPlayer): RpcServerContext;
+    protected forward(): void;
+    callClient<R = any>(player: MpPlayer | number, method: string, options?: CallConfig): Promise<R>;
+    callClient<R = any>(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerClient(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>): void;
+    callBrowser<R = any>(player: MpPlayer | number, method: string, options?: CallConfig): Promise<R>;
+    callBrowser<R = any>(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerBrowser(player: MpPlayer | number, method: string, data?: any, meta?: Record<string, any>): void;
+}
+
+export { RpcServer, RpcServerContext };

package/dist/index.mjs

@@ -0,0 +1,131 @@
+import { RpcDatabus, RpcBase } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcPacketType, RpcPacket, MpEnv } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+class RpcServerContext extends RpcContext {
+  player;
+  constructor(options, player) {
+    super(options);
+    this.player = player;
+  }
+}
+
+class RpcServerDatabus extends RpcDatabus {
+  constructor(options) {
+    super(options);
+    this.setupListeners();
+  }
+  setupListeners() {
+    mp.events.onClient(this.RPC_INVOKE_EVENT, (player, packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), player);
+    });
+    mp.events.onClient(this.RPC_RESPONSE_EVENT, (player, packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), player);
+    });
+  }
+  send(packet, player) {
+    if (!player) {
+      return;
+    }
+    const eventNamesMap = {
+      [RpcPacketType.CALL]: this.RPC_INVOKE_EVENT,
+      [RpcPacketType.TRIGGER]: this.RPC_INVOKE_EVENT,
+      [RpcPacketType.RESPONSE]: this.RPC_RESPONSE_EVENT
+    };
+    const eventName = eventNamesMap[packet.type];
+    if (!eventName) {
+      return;
+    }
+    mp.events.emitClient(player, eventName, this.serialize(packet));
+  }
+}
+
+class RpcServer extends RpcBase {
+  databus;
+  constructor(options = {}) {
+    super(options);
+    this.databus = new RpcServerDatabus(this.options);
+    this.init();
+  }
+  async internalCall(packet, options, player) {
+    return new Promise((resolve, reject) => {
+      this.pendingStore.addPending({
+        resolve,
+        reject,
+        packet,
+        ...options
+      });
+      this.databus.send(packet, player);
+    });
+  }
+  internalTrigger(packet, player) {
+    this.databus.send(packet, player);
+  }
+  createContext(packet, player) {
+    return new RpcServerContext(
+      {
+        data: packet.data,
+        meta: packet.meta,
+        packet
+      },
+      player
+    );
+  }
+  forward() {
+    console.error("Forwarding packets in server is unsupported");
+  }
+  callClient(player, method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.CLIENT }
+    );
+    return this.call(packet, options, player);
+  }
+  triggerClient(player, method, data, meta) {
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.CLIENT }
+    );
+    this.trigger(packet, player);
+  }
+  callBrowser(player, method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.BROWSER }
+    );
+    return this.call(packet, options, player);
+  }
+  triggerBrowser(player, method, data, meta) {
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.BROWSER }
+    );
+    this.trigger(packet, player);
+  }
+}
+
+export { RpcServer, RpcServerContext };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@cybermp/rpc-server",
+  "version": "0.1.0-rc.1",
+  "keywords": [],
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@cybermp/rpc-core": "0.1.0-rc.1"
+  },
+  "unbuild": {
+    "failOnWarn": false
+  },
+  "peerDependencies": {
+    "@cybermp/server-types": "^2.0.2"
+  },
+  "scripts": {
+    "dev": "pnpm run build --watch",
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}