@open-core/ragemp-adapter 1.0.0 → 1.0.2

package/dist/server/ragemp-exports.d.ts

@@ -1,7 +1,58 @@
 import { IExports, IResourceInfo } from '@open-core/framework/contracts/server';
 export declare class RageMPExports extends IExports {
     private readonly resourceInfo;
+    private readonly currentResourceName;
+    private readonly requestEventName;
+    private readonly responseEventName;
+    private readonly pendingRequests;
+    private readonly localHandlers;
     constructor(resourceInfo: IResourceInfo);
     register(exportName: string, handler: (...args: readonly unknown[]) => unknown): void;
+    /**
+     * Resolves exports through the local registry shared by the current adapter runtime.
+     */
     getResource<T = unknown>(resourceName: string): T | undefined;
+    /**
+     * Returns an async proxy that forwards method calls to another server resource.
+     *
+     * @remarks
+     * The proxy intentionally ignores Promise-like properties (`then`, `catch`, `finally`)
+     * so `await` does not accidentally treat the proxy itself as a thenable.
+     */
+    getRemoteResource<T = unknown>(resourceName: string): T;
+    /**
+     * Invokes a remote export by sending a server-side RageMP event to the target resource.
+     */
+    callRemoteExport<TResult = unknown>(resourceName: string, exportName: string, ...args: unknown[]): Promise<TResult>;
+    /**
+     * Waits for a remote resource to expose a matching export before returning the async proxy.
+     */
+    waitForRemoteResource<T = unknown>(resourceName: string, options?: {
+        exportName?: string;
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<T>;
+    /**
+     * Installs the request/response listeners used by the optional remote export helper layer.
+     *
+     * @remarks
+     * The listeners reject payloads that look like player-originated server events so clients
+     * cannot invoke server resource exports through this transport.
+     */
+    private registerTransportListeners;
+    /**
+     * Executes one remote export request against handlers registered in the current resource.
+     */
+    private handleExportRequest;
+    /**
+     * Resolves or rejects the pending promise associated with a remote export response.
+     */
+    private handleExportResponse;
+    /**
+     * Executes an export from the current resource without going back through the shared registry.
+     */
+    private executeLocalExport;
+    private createRequestId;
+    private serializeError;
+    private deserializeError;
 }

package/dist/server/ragemp-exports.js

@@ -16,17 +16,218 @@ exports.RageMPExports = void 0;
 const tsyringe_1 = require("tsyringe");
 const server_1 = require("@open-core/framework/contracts/server");
 const exports_registry_1 = require("../shared/exports-registry");
+const REQUEST_EVENT_PREFIX = '__oc:exports:req:';
+const RESPONSE_EVENT_PREFIX = '__oc:exports:res:';
+const EXPORTS_TIMEOUT_MS = 7500;
+const WAIT_INTERVAL_MS = 150;
+const META_HAS_EXPORT = '__oc_meta_has_export__';
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isPlayerMpLike(value) {
+    return isObjectRecord(value) && 'id' in value && 'serial' in value;
+}
+function isExportRequestPayload(value) {
+    return (isObjectRecord(value) &&
+        typeof value.requestId === 'string' &&
+        typeof value.callerResource === 'string' &&
+        typeof value.exportName === 'string' &&
+        Array.isArray(value.args));
+}
+function isExportResponsePayload(value) {
+    if (!isObjectRecord(value) ||
+        typeof value.requestId !== 'string' ||
+        typeof value.ok !== 'boolean') {
+        return false;
+    }
+    if (value.ok) {
+        return true;
+    }
+    return (isObjectRecord(value.error) &&
+        typeof value.error.name === 'string' &&
+        typeof value.error.message === 'string');
+}
 let RageMPExports = class RageMPExports extends server_1.IExports {
     constructor(resourceInfo) {
         super();
         this.resourceInfo = resourceInfo;
+        this.pendingRequests = new Map();
+        this.localHandlers = new Map();
+        this.currentResourceName = this.resourceInfo.getCurrentResourceName();
+        this.requestEventName = `${REQUEST_EVENT_PREFIX}${this.currentResourceName}`;
+        this.responseEventName = `${RESPONSE_EVENT_PREFIX}${this.currentResourceName}`;
+        this.registerTransportListeners();
     }
     register(exportName, handler) {
-        exports_registry_1.exportsRegistry.register(this.resourceInfo.getCurrentResourceName(), exportName, handler);
+        this.localHandlers.set(exportName, handler);
+        exports_registry_1.exportsRegistry.register(this.currentResourceName, exportName, handler);
     }
+    /**
+     * Resolves exports through the local registry shared by the current adapter runtime.
+     */
     getResource(resourceName) {
         return exports_registry_1.exportsRegistry.resourceProxy(resourceName);
     }
+    /**
+     * Returns an async proxy that forwards method calls to another server resource.
+     *
+     * @remarks
+     * The proxy intentionally ignores Promise-like properties (`then`, `catch`, `finally`)
+     * so `await` does not accidentally treat the proxy itself as a thenable.
+     */
+    getRemoteResource(resourceName) {
+        return new Proxy({}, {
+            get: (_, exportName) => {
+                if (typeof exportName !== 'string' ||
+                    exportName === 'then' ||
+                    exportName === 'catch' ||
+                    exportName === 'finally') {
+                    return undefined;
+                }
+                return (...args) => this.callRemoteExport(resourceName, exportName, ...args);
+            },
+        });
+    }
+    /**
+     * Invokes a remote export by sending a server-side RageMP event to the target resource.
+     */
+    callRemoteExport(resourceName, exportName, ...args) {
+        const requestId = this.createRequestId(resourceName, exportName);
+        const requestEventName = `${REQUEST_EVENT_PREFIX}${resourceName}`;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`[exports] Timed out calling "${exportName}" on resource "${resourceName}".`));
+            }, EXPORTS_TIMEOUT_MS);
+            this.pendingRequests.set(requestId, { resolve, reject, timeout });
+            mp.events.call(requestEventName, {
+                requestId,
+                callerResource: this.currentResourceName,
+                exportName,
+                args,
+            });
+        });
+    }
+    /**
+     * Waits for a remote resource to expose a matching export before returning the async proxy.
+     */
+    async waitForRemoteResource(resourceName, options) {
+        const timeoutMs = options?.timeoutMs ?? EXPORTS_TIMEOUT_MS;
+        const intervalMs = options?.intervalMs ?? WAIT_INTERVAL_MS;
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            try {
+                const isAvailable = await this.callRemoteExport(resourceName, META_HAS_EXPORT, options?.exportName);
+                if (isAvailable) {
+                    return this.getRemoteResource(resourceName);
+                }
+            }
+            catch {
+                // Ignore transient availability failures while waiting.
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error(`[exports] Timed out waiting for resource "${resourceName}" remote exports.`);
+    }
+    /**
+     * Installs the request/response listeners used by the optional remote export helper layer.
+     *
+     * @remarks
+     * The listeners reject payloads that look like player-originated server events so clients
+     * cannot invoke server resource exports through this transport.
+     */
+    registerTransportListeners() {
+        mp.events.add(this.requestEventName, (...args) => {
+            const payload = args[0];
+            if (isPlayerMpLike(payload) || !isExportRequestPayload(payload)) {
+                return;
+            }
+            void this.handleExportRequest(payload);
+        });
+        mp.events.add(this.responseEventName, (...args) => {
+            const payload = args[0];
+            if (isPlayerMpLike(payload) || !isExportResponsePayload(payload)) {
+                return;
+            }
+            this.handleExportResponse(payload);
+        });
+    }
+    /**
+     * Executes one remote export request against handlers registered in the current resource.
+     */
+    async handleExportRequest(payload) {
+        const responseEventName = `${RESPONSE_EVENT_PREFIX}${payload.callerResource}`;
+        try {
+            const result = await this.executeLocalExport(payload.exportName, payload.args);
+            mp.events.call(responseEventName, {
+                requestId: payload.requestId,
+                ok: true,
+                result,
+            });
+        }
+        catch (error) {
+            mp.events.call(responseEventName, {
+                requestId: payload.requestId,
+                ok: false,
+                error: this.serializeError(error),
+            });
+        }
+    }
+    /**
+     * Resolves or rejects the pending promise associated with a remote export response.
+     */
+    handleExportResponse(payload) {
+        const pendingRequest = this.pendingRequests.get(payload.requestId);
+        if (!pendingRequest) {
+            return;
+        }
+        clearTimeout(pendingRequest.timeout);
+        this.pendingRequests.delete(payload.requestId);
+        if (payload.ok) {
+            pendingRequest.resolve(payload.result);
+            return;
+        }
+        pendingRequest.reject(this.deserializeError(payload.error));
+    }
+    /**
+     * Executes an export from the current resource without going back through the shared registry.
+     */
+    async executeLocalExport(exportName, args) {
+        if (exportName === META_HAS_EXPORT) {
+            const requestedExportName = typeof args[0] === 'string' ? args[0] : undefined;
+            if (!requestedExportName) {
+                return this.localHandlers.size > 0;
+            }
+            return this.localHandlers.has(requestedExportName);
+        }
+        const handler = this.localHandlers.get(exportName);
+        if (!handler) {
+            throw new Error(`[exports] Export "${exportName}" not found in resource "${this.currentResourceName}".`);
+        }
+        return Promise.resolve(handler(...args));
+    }
+    createRequestId(resourceName, exportName) {
+        return `${this.currentResourceName}:${resourceName}:${exportName}:${Date.now()}:${Math.random()}`;
+    }
+    serializeError(error) {
+        if (error instanceof Error) {
+            return {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+        }
+        return {
+            name: 'Error',
+            message: String(error),
+        };
+    }
+    deserializeError(error) {
+        const result = new Error(error.message);
+        result.name = error.name;
+        result.stack = error.stack;
+        return result;
+    }
 };
 exports.RageMPExports = RageMPExports;
 exports.RageMPExports = RageMPExports = __decorate([

package/dist/shared/transport/ragemp.rpc.js

@@ -3,11 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMPRpc = void 0;
 const contracts_1 = require("@open-core/framework/contracts");
 const helpers_1 = require("./helpers");
-function asErrorInfo(error) {
-    if (error instanceof Error) {
-        return { message: error.message, name: error.name };
+function serializeRpcError(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        'expose' in error &&
+        error.expose === true) {
+        return {
+            message: error.message,
+            name: 'name' in error && typeof error.name === 'string' ? error.name : undefined,
+        };
     }
-    return { message: String(error) };
+    return { message: 'An internal server error occurred' };
 }
 function getCurrentResourceNameSafe() {
     if (typeof __OPENCORE_RESOURCE_NAME__ === 'string' && __OPENCORE_RESOURCE_NAME__.trim()) {
@@ -148,7 +156,7 @@ class RageMPRpc extends contracts_1.RpcAPI {
             }
         }
         catch (err) {
-            const errorInfo = asErrorInfo(err);
+            const errorInfo = serializeRpcError(err);
             if (msg.kind === 'notify') {
                 this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/ragemp-adapter",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "External Rage Multiplayer adapter for OpenCore framework.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,7 +43,7 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.8",
+    "@biomejs/biome": "^2.4.10",
     "@open-core/framework": "latest",
     "@ragempcommunity/types-client": "^2.1.9",
     "@ragempcommunity/types-server": "^2.1.9",