@cybermp/rpc-core 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/definitions/index.mjs

@@ -0,0 +1,15 @@
+export { M as MpEnv } from '../shared/rpc-core.cYKWyseL.mjs';
+export { C as CommonRpcErrorCode, R as RpcApplyType, a as RpcEnv, b as RpcError, d as RpcPacket, c as RpcPacketType, g as getRpcError } from '../shared/rpc-core.IrPp0Y0i.mjs';
+
+class RpcContext {
+  data;
+  meta;
+  packet;
+  constructor({ data, meta, packet }) {
+    this.data = data;
+    this.meta = meta;
+    this.packet = packet;
+  }
+}
+
+export { RpcContext };

package/dist/index.mjs

@@ -0,0 +1,384 @@
+import { C as CURRENT_ENVIRONMENT } from './shared/rpc-core.cYKWyseL.mjs';
+import { b as RpcError, d as RpcPacket, c as RpcPacketType, R as RpcApplyType, g as getRpcError } from './shared/rpc-core.IrPp0Y0i.mjs';
+
+class RpcInterceptorManager {
+  handlers = [];
+  use(handler) {
+    this.handlers.push(handler);
+    return this.handlers.length - 1;
+  }
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+  getHandlers() {
+    return this.handlers.filter((h) => h !== null);
+  }
+}
+
+class RpcOptions {
+  throwUnknownMethods = true;
+  maxPending = 1e3;
+  pendingTimeout = 1e4;
+  prefix = "";
+  serializer;
+}
+
+const anyAbortSignal = (iterable) => {
+  const controller = new AbortController();
+  function abort() {
+    controller.abort(this.reason);
+    clean();
+  }
+  function clean() {
+    for (const signal of iterable) {
+      signal.removeEventListener("abort", abort);
+    }
+  }
+  for (const signal of iterable) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    } else {
+      signal.addEventListener("abort", abort);
+    }
+  }
+  return controller.signal;
+};
+const timeoutAbortSignal = (ms) => {
+  const controller = new AbortController();
+  setTimeout(() => {
+    controller.abort("TimeoutError");
+  }, ms);
+  return controller.signal;
+};
+
+class RpcPendingStore {
+  constructor(options) {
+    this.options = options;
+  }
+  pendingRequests = /* @__PURE__ */ new Map();
+  processPending({ resolve, reject, packet }) {
+    if (!packet) {
+      return;
+    }
+    if (packet.error) {
+      reject(packet.error);
+    } else {
+      resolve(packet.data);
+    }
+  }
+  addPending({
+    packet,
+    reject,
+    resolve,
+    // TODO: sync abort signals both ways, so if request was aborted from client, it execution would also abort in registry
+    signal: externalSignal,
+    timeout
+  }) {
+    const { id, method } = packet;
+    if (!id) {
+      return;
+    }
+    const timeoutValue = timeout || this.options.pendingTimeout;
+    const combinedSignal = anyAbortSignal([
+      ...externalSignal ? [externalSignal] : [],
+      ...timeoutValue ? [timeoutAbortSignal(timeoutValue)] : []
+    ]);
+    const onAbort = () => {
+      this.pendingRequests.delete(id);
+      const isTimeout = combinedSignal.reason?.name === "TimeoutError" || combinedSignal.reason === "TimeoutError";
+      const error = isTimeout ? RpcError.timeout({
+        message: `RPC call ${method}:${id} timed out after ${timeoutValue}ms`,
+        method,
+        data: combinedSignal.reason
+      }) : new RpcError({
+        method,
+        data: combinedSignal.reason,
+        message: combinedSignal.reason
+      });
+      this.processPending({
+        reject,
+        resolve,
+        packet: new RpcPacket(
+          { id, method, error, type: RpcPacketType.RESPONSE },
+          { target: CURRENT_ENVIRONMENT }
+        )
+      });
+    };
+    if (combinedSignal.aborted) {
+      onAbort();
+      return;
+    }
+    if (this.options.maxPending && this.pendingRequests.size >= this.options.maxPending) {
+      const error = RpcError.tooManyPendingRequests();
+      this.processPending({
+        reject,
+        resolve,
+        packet: new RpcPacket(
+          { id, method, error, type: RpcPacketType.RESPONSE },
+          { target: CURRENT_ENVIRONMENT }
+        )
+      });
+      return;
+    }
+    combinedSignal.addEventListener("abort", onAbort, { once: true });
+    this.pendingRequests.set(id, async (packet2) => {
+      combinedSignal.removeEventListener("abort", onAbort);
+      this.pendingRequests.delete(id);
+      this.processPending({ reject, resolve, packet: packet2 });
+    });
+  }
+  resolvePending(packet) {
+    if (!packet.id || packet.type !== RpcPacketType.RESPONSE) {
+      return;
+    }
+    const handler = this.pendingRequests.get(packet.id);
+    if (!handler) {
+      return;
+    }
+    handler(packet);
+  }
+}
+
+class RpcRegistry {
+  constructor(options) {
+    this.options = options;
+  }
+  globalMiddlewares = [];
+  callHandlers = /* @__PURE__ */ new Map();
+  triggerHandlers = /* @__PURE__ */ new Map();
+  use(...middlewares) {
+    this.globalMiddlewares.push(...middlewares);
+  }
+  isApplied(method, type) {
+    if (type === RpcApplyType.ON) {
+      return this.triggerHandlers.has(method);
+    } else if (type === RpcApplyType.REGISTER) {
+      return this.callHandlers.has(method);
+    }
+  }
+  register(method, ...stack) {
+    this.callHandlers.set(method, stack);
+  }
+  unregister(method) {
+    this.callHandlers.delete(method);
+  }
+  on(eventName, ...stack) {
+    if (!this.triggerHandlers.has(eventName)) {
+      this.triggerHandlers.set(eventName, []);
+    }
+    this.triggerHandlers.get(eventName).push(stack);
+  }
+  off(eventName, handler) {
+    const containers = this.triggerHandlers.get(eventName);
+    if (!containers) {
+      return;
+    }
+    const index = containers.findIndex(
+      (c) => c[c.length - 1] === handler
+    );
+    if (index !== -1) {
+      containers.splice(index, 1);
+    }
+    if (containers.length === 0) {
+      this.triggerHandlers.delete(eventName);
+    }
+  }
+  offAll(eventName) {
+    this.triggerHandlers.delete(eventName);
+  }
+  async execute(ctx) {
+    const { type, method } = ctx.packet;
+    if (type === RpcPacketType.CALL) {
+      const stack = this.callHandlers.get(method);
+      if (!stack) {
+        if (this.options.throwUnknownMethods) {
+          throw RpcError.methodNotFound({ method });
+        }
+        return;
+      }
+      return this.runStack(ctx, stack);
+    }
+    if (type === RpcPacketType.TRIGGER) {
+      const listenerStacks = this.triggerHandlers.get(method);
+      if (!listenerStacks) {
+        return;
+      }
+      for (const stack of listenerStacks) {
+        this.runStack(ctx, stack).catch((err) => {
+          console.error("RPC UNHANDLDED REJECTION", err);
+        });
+      }
+    }
+  }
+  async runStack(ctx, handlers) {
+    const fullStack = [...this.globalMiddlewares, ...handlers];
+    let index = 0;
+    const next = async () => {
+      if (index >= fullStack.length) {
+        return;
+      }
+      const current = fullStack[index++];
+      try {
+        return await current?.(ctx, next);
+      } catch (err) {
+        throw getRpcError(err, ctx.packet.method);
+      }
+    };
+    return next();
+  }
+}
+
+class RpcBase {
+  options;
+  registry;
+  pendingStore;
+  interceptors = {
+    request: new RpcInterceptorManager(),
+    response: new RpcInterceptorManager()
+  };
+  constructor(options = {}) {
+    this.options = Object.assign(new RpcOptions(), options);
+    this.registry = new RpcRegistry(this.options);
+    this.pendingStore = new RpcPendingStore(this.options);
+  }
+  async call(packet, options, remoteInfo) {
+    const interceptedPacket = await this.runRequestInterceptors(packet);
+    return this.internalCall(interceptedPacket, options, remoteInfo);
+  }
+  async trigger(packet, remoteInfo) {
+    const interceptedPacket = await this.runRequestInterceptors(packet);
+    this.internalTrigger(interceptedPacket, remoteInfo);
+  }
+  init() {
+    this.databus.listen(
+      (packet, remoteInfo) => this.handleIncoming(packet, remoteInfo)
+    );
+  }
+  async runRequestInterceptors(request) {
+    let req = { ...request };
+    for (const handler of this.interceptors.request.getHandlers()) {
+      req = await handler(req);
+    }
+    return req;
+  }
+  async runResponseInterceptors(response) {
+    let res = { ...response };
+    if (res.error) {
+      let error = res.error;
+      for (const handler of this.interceptors.response.getHandlers()) {
+        if (handler.onRejected) {
+          error = await handler.onRejected(error);
+        }
+      }
+      res.error = error;
+      return res;
+    }
+    for (const handler of this.interceptors.response.getHandlers()) {
+      if (handler.onFulfilled) {
+        res = await handler.onFulfilled(res);
+      }
+    }
+    return res;
+  }
+  async handleIncoming(packet, remoteInfo) {
+    if (packet.env.target !== CURRENT_ENVIRONMENT) {
+      return this.forward(packet, remoteInfo);
+    }
+    if (packet.type === RpcPacketType.RESPONSE) {
+      this.pendingStore.resolvePending(
+        await this.runResponseInterceptors(packet)
+      );
+      return;
+    }
+    const ctx = this.createContext(packet, remoteInfo);
+    try {
+      const result = await this.registry.execute(ctx);
+      if (packet.type === RpcPacketType.CALL && packet.id) {
+        this.sendResponse(packet, result, remoteInfo);
+      }
+    } catch (err) {
+      if (packet.type === RpcPacketType.CALL && packet.id) {
+        this.sendResponse(packet, null, remoteInfo, err);
+      }
+    }
+  }
+  sendResponse(original, data, remoteInfo, error) {
+    const response = new RpcPacket(
+      {
+        id: original.id,
+        method: original.method,
+        type: RpcPacketType.RESPONSE,
+        data,
+        error: error ? getRpcError(error, original.method) : void 0
+      },
+      { target: original.env.source }
+    );
+    this.databus.send(response, remoteInfo);
+  }
+  parseCallArgs(args) {
+    const [first, second, third] = args;
+    const isConfig = (obj) => {
+      return obj && typeof obj === "object" && ("timeout" in obj || "signal" in obj || "data" in obj || "meta" in obj);
+    };
+    if (args.length === 1 && isConfig(first)) {
+      return {
+        data: first.data,
+        meta: first.meta,
+        options: first
+      };
+    }
+    return {
+      data: first,
+      meta: second,
+      options: third
+    };
+  }
+  on(eventName, ...stack) {
+    this.registry.on(eventName, ...stack);
+  }
+  register(method, ...stack) {
+    this.registry.register(method, ...stack);
+  }
+  unregister(method) {
+    this.registry.unregister(method);
+  }
+  isApplied(method, type) {
+    return this.registry.isApplied(method, type);
+  }
+  off(eventName, handler) {
+    this.registry.off(eventName, handler);
+  }
+  offAll(eventName) {
+    this.registry.offAll(eventName);
+  }
+  use(...middlewares) {
+    this.registry.use(...middlewares);
+  }
+}
+
+class RpcDatabus {
+  constructor(options) {
+    this.options = options;
+  }
+  get RPC_INVOKE_EVENT() {
+    return `${this.options.prefix}__rpc:invoke`;
+  }
+  get RPC_RESPONSE_EVENT() {
+    return `${this.options.prefix}__rpc:response`;
+  }
+  serialize(obj) {
+    return this.options.serializer?.serialize(obj) ?? obj;
+  }
+  deserialize(obj) {
+    return this.options.serializer?.deserialize(obj) ?? obj;
+  }
+  onPacketReceived;
+  listen(cb) {
+    this.onPacketReceived = cb;
+  }
+}
+
+export { RpcBase, RpcDatabus, RpcOptions, RpcPendingStore, RpcRegistry };

package/dist/shared/rpc-core.IrPp0Y0i.mjs

@@ -0,0 +1,146 @@
+import { C as CURRENT_ENVIRONMENT, g as generateUUID } from './rpc-core.cYKWyseL.mjs';
+
+var RpcApplyType = /* @__PURE__ */ ((RpcApplyType2) => {
+  RpcApplyType2["ON"] = "on";
+  RpcApplyType2["REGISTER"] = "register";
+  return RpcApplyType2;
+})(RpcApplyType || {});
+
+class RpcEnv {
+  source = CURRENT_ENVIRONMENT;
+  target;
+  constructor(opts) {
+    this.source = opts?.source ?? CURRENT_ENVIRONMENT;
+    this.target = opts.target;
+  }
+}
+
+var CommonRpcErrorCode = /* @__PURE__ */ ((CommonRpcErrorCode2) => {
+  CommonRpcErrorCode2["UNKNOWN"] = "UNKNOWN";
+  CommonRpcErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  CommonRpcErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  CommonRpcErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  CommonRpcErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
+  CommonRpcErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  CommonRpcErrorCode2["TIMEOUT"] = "TIMEOUT";
+  CommonRpcErrorCode2["INVALID_DATA"] = "INVALID_DATA";
+  CommonRpcErrorCode2["TOO_MANY_PENDING_REQUESTS"] = "TOO_MANY_PENDING_REQUESTS";
+  return CommonRpcErrorCode2;
+})(CommonRpcErrorCode || {});
+class RpcError extends Error {
+  code;
+  data;
+  method;
+  constructor(options = {}) {
+    super(options.message);
+    this.code = options.code ?? "UNKNOWN" /* UNKNOWN */;
+    this.data = options.data;
+    this.method = options.method;
+  }
+  static unknown(options = {}) {
+    return new RpcError({
+      message: "Unknown error happened",
+      ...options,
+      code: "UNKNOWN" /* UNKNOWN */
+    });
+  }
+  static tooManyPendingRequests(options = {}) {
+    return new RpcError({
+      message: "Too many pending requests",
+      ...options,
+      code: "TOO_MANY_PENDING_REQUESTS" /* TOO_MANY_PENDING_REQUESTS */
+    });
+  }
+  static unauthorized(options = {}) {
+    return new RpcError({
+      message: "Unauthorized",
+      ...options,
+      code: "UNAUTHORIZED" /* UNAUTHORIZED */
+    });
+  }
+  static forbidden(options = {}) {
+    return new RpcError({
+      message: "Forbidden",
+      ...options,
+      code: "FORBIDDEN" /* FORBIDDEN */
+    });
+  }
+  static notFound(options = {}) {
+    return new RpcError({
+      message: "Not found",
+      ...options,
+      code: "NOT_FOUND" /* NOT_FOUND */
+    });
+  }
+  static methodNotFound(options = {}) {
+    return new RpcError({
+      message: "Method not found",
+      ...options,
+      code: "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */
+    });
+  }
+  static internalError(options = {}) {
+    return new RpcError({
+      message: "An unexpected error occurred",
+      ...options,
+      code: "INTERNAL_ERROR" /* INTERNAL_ERROR */
+    });
+  }
+  static timeout(options = {}) {
+    return new RpcError({
+      message: "Request timed out",
+      ...options,
+      code: "TIMEOUT" /* TIMEOUT */
+    });
+  }
+  static invalidData(options = {}) {
+    return new RpcError({
+      message: "Invalid data provided",
+      ...options,
+      code: "INVALID_DATA" /* INVALID_DATA */
+    });
+  }
+}
+const getRpcError = (err, method) => {
+  if (!(err instanceof RpcError)) {
+    return RpcError.internalError({ method });
+  }
+  if (!err.method) {
+    err.method = method;
+  }
+  return err;
+};
+
+var RpcPacketType = /* @__PURE__ */ ((RpcPacketType2) => {
+  RpcPacketType2["CALL"] = "call";
+  RpcPacketType2["TRIGGER"] = "trigger";
+  RpcPacketType2["RESPONSE"] = "response";
+  return RpcPacketType2;
+})(RpcPacketType || {});
+class RpcPacket {
+  id;
+  type;
+  method;
+  data;
+  meta;
+  error;
+  env;
+  constructor({
+    id,
+    type,
+    data = {},
+    method,
+    error,
+    meta = {}
+  }, env) {
+    this.id = id ?? (type === "call" /* CALL */ ? generateUUID() : null);
+    this.type = type;
+    this.method = method;
+    this.data = data;
+    this.meta = meta;
+    this.error = error;
+    this.env = new RpcEnv(env);
+  }
+}
+
+export { CommonRpcErrorCode as C, RpcApplyType as R, RpcEnv as a, RpcError as b, RpcPacketType as c, RpcPacket as d, getRpcError as g };

package/dist/shared/rpc-core.cYKWyseL.mjs

@@ -0,0 +1,41 @@
+var MpEnv = /* @__PURE__ */ ((MpEnv2) => {
+  MpEnv2["BROWSER"] = "browser";
+  MpEnv2["CLIENT"] = "client";
+  MpEnv2["SERVER"] = "server";
+  return MpEnv2;
+})(MpEnv || {});
+
+const getEnvironment = () => {
+  const mp = globalThis.mp;
+  if (!mp) {
+    throw new Error('Unresolved environment: global "mp" object not found');
+  }
+  if (mp.isServer?.()) {
+    return MpEnv.SERVER;
+  }
+  if (mp.events?.onServer !== void 0) {
+    return MpEnv.CLIENT;
+  }
+  if (mp.events?.emit !== void 0) {
+    return MpEnv.BROWSER;
+  }
+  throw new Error("Unresolved environment: mp object properties unrecognized");
+};
+const CURRENT_ENVIRONMENT = getEnvironment();
+
+const generateUUID = () => {
+  let d = Date.now(), d2 = typeof performance !== "undefined" && performance.now && performance.now() * 1e3 || 0;
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    let r = Math.random() * 16;
+    if (d > 0) {
+      r = (d + r) % 16 | 0;
+      d = Math.floor(d / 16);
+    } else {
+      r = (d2 + r) % 16 | 0;
+      d2 = Math.floor(d2 / 16);
+    }
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+};
+
+export { CURRENT_ENVIRONMENT as C, MpEnv as M, getEnvironment as a, generateUUID as g };

package/dist/utils/index.mjs

@@ -0,0 +1 @@
+export { C as CURRENT_ENVIRONMENT, g as generateUUID, a as getEnvironment } from '../shared/rpc-core.cYKWyseL.mjs';

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@cybermp/rpc-core",
+  "version": "0.1.0-rc.1",
+  "keywords": [],
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.ts",
+    "./utils": "./src/utils/index.ts",
+    "./definitions": "./src/definitions/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "unbuild": {
+    "failOnWarn": false
+  },
+  "scripts": {
+    "dev": "pnpm run build --watch",
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}