@open-core/framework 0.1.0-alpha.1 → 0.2.1-beta.1

package/dist/runtime/server/controllers/player-export.controller.js

@@ -0,0 +1,173 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerExportController = void 0;
+const controller_1 = require("../decorators/controller");
+const export_1 = require("../decorators/export");
+const player_directory_port_1 = require("../services/ports/player-directory.port");
+/**
+ * Exports player directory functionality for RESOURCE mode access.
+ *
+ * @remarks
+ * This controller provides a complete API for remote resources to:
+ * - Query player data (by client ID, account ID, or all players)
+ * - Check online status and player count
+ * - Read/write session metadata
+ * - Manage player state flags
+ */
+let PlayerExportController = class PlayerExportController {
+    constructor(playerService) {
+        this.playerService = playerService;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Basic Player Queries
+    // ═══════════════════════════════════════════════════════════════
+    getPlayerId(clientID) {
+        return this.playerService.getPlayerId(clientID);
+    }
+    getPlayerData(clientID) {
+        var _a;
+        const player = this.playerService.getByClient(clientID);
+        return (_a = player === null || player === void 0 ? void 0 : player.serialize()) !== null && _a !== void 0 ? _a : null;
+    }
+    getManyData(clientIds) {
+        return this.playerService.getMany(clientIds).map((p) => p.serialize());
+    }
+    getAllPlayersData() {
+        return this.playerService.getAll().map((p) => p.serialize());
+    }
+    getPlayerByAccountId(accountId) {
+        var _a;
+        const players = this.playerService.getAll();
+        const player = players.find((p) => p.accountID === accountId);
+        return (_a = player === null || player === void 0 ? void 0 : player.serialize()) !== null && _a !== void 0 ? _a : null;
+    }
+    getPlayerCount() {
+        return this.playerService.getAll().length;
+    }
+    isPlayerOnline(accountId) {
+        const players = this.playerService.getAll();
+        return players.some((p) => p.accountID === accountId);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Metadata Operations
+    // ═══════════════════════════════════════════════════════════════
+    async getPlayerMeta(clientID, key) {
+        return await this.playerService.getMeta(clientID, key);
+    }
+    setPlayerMeta(clientID, key, value) {
+        this.playerService.setMeta(clientID, key, value);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // State Management
+    // ═══════════════════════════════════════════════════════════════
+    getPlayerStates(clientID) {
+        var _a;
+        const player = this.playerService.getByClient(clientID);
+        return (_a = player === null || player === void 0 ? void 0 : player.getStates()) !== null && _a !== void 0 ? _a : [];
+    }
+    hasPlayerState(clientID, state) {
+        var _a;
+        const player = this.playerService.getByClient(clientID);
+        return (_a = player === null || player === void 0 ? void 0 : player.hasState(state)) !== null && _a !== void 0 ? _a : false;
+    }
+    addPlayerState(clientID, state) {
+        const player = this.playerService.getByClient(clientID);
+        player === null || player === void 0 ? void 0 : player.addState(state);
+    }
+    removePlayerState(clientID, state) {
+        const player = this.playerService.getByClient(clientID);
+        player === null || player === void 0 ? void 0 : player.removeState(state);
+    }
+};
+exports.PlayerExportController = PlayerExportController;
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Object)
+], PlayerExportController.prototype, "getPlayerId", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Object)
+], PlayerExportController.prototype, "getPlayerData", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Array)
+], PlayerExportController.prototype, "getManyData", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], PlayerExportController.prototype, "getAllPlayersData", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], PlayerExportController.prototype, "getPlayerByAccountId", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Number)
+], PlayerExportController.prototype, "getPlayerCount", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Boolean)
+], PlayerExportController.prototype, "isPlayerOnline", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", Promise)
+], PlayerExportController.prototype, "getPlayerMeta", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String, Object]),
+    __metadata("design:returntype", void 0)
+], PlayerExportController.prototype, "setPlayerMeta", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Array)
+], PlayerExportController.prototype, "getPlayerStates", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", Boolean)
+], PlayerExportController.prototype, "hasPlayerState", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", void 0)
+], PlayerExportController.prototype, "addPlayerState", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", void 0)
+], PlayerExportController.prototype, "removePlayerState", null);
+exports.PlayerExportController = PlayerExportController = __decorate([
+    (0, controller_1.Controller)(),
+    __metadata("design:paramtypes", [player_directory_port_1.PlayerDirectoryPort])
+], PlayerExportController);

package/dist/runtime/server/controllers/principal-export.controller.d.ts

@@ -0,0 +1,79 @@
+import { Principal, PrincipalProviderContract } from '../contracts/index';
+import { GuardOptions } from '../decorators/guard';
+import { PlayerDirectoryPort } from '../services/ports/player-directory.port';
+/**
+ * Exports principal/permission functionality for RESOURCE mode access.
+ *
+ * @remarks
+ * This controller provides a complete API for remote resources to:
+ * - Query player permissions and ranks
+ * - Perform quick authorization checks
+ * - Refresh cached permissions
+ * - Query offline player permissions by account ID
+ */
+export declare class PrincipalExportController {
+    private readonly playerService;
+    private readonly principalProvider;
+    constructor(playerService: PlayerDirectoryPort, principalProvider: PrincipalProviderContract);
+    /**
+     * Gets the full Principal object for a player.
+     */
+    getPrincipal(source: number): Promise<Principal | null>;
+    /**
+     * Gets Principal by account ID (works for offline players too).
+     */
+    getPrincipalByAccountId(accountId: string): Promise<Principal | null>;
+    /**
+     * Forces a refresh of the player's permissions from persistence.
+     */
+    refreshPrincipal(source: number): Promise<void>;
+    /**
+     * Checks if player has a specific permission.
+     *
+     * @remarks
+     * Supports wildcard '*' permission for super-admin access.
+     */
+    hasPermission(source: number, permission: string): Promise<boolean>;
+    /**
+     * Checks if player has at least the required rank.
+     *
+     * @remarks
+     * Uses numeric comparison: playerRank >= requiredRank
+     */
+    hasRank(source: number, requiredRank: number): Promise<boolean>;
+    /**
+     * Checks if player has ANY of the specified permissions.
+     */
+    hasAnyPermission(source: number, permissions: string[]): Promise<boolean>;
+    /**
+     * Checks if player has ALL of the specified permissions.
+     */
+    hasAllPermissions(source: number, permissions: string[]): Promise<boolean>;
+    /**
+     * Gets all permissions for a player.
+     */
+    getPermissions(source: number): Promise<string[]>;
+    /**
+     * Gets the rank value for a player.
+     */
+    getRank(source: number): Promise<number | null>;
+    /**
+     * Gets the principal name/role name for a player.
+     */
+    getPrincipalName(source: number): Promise<string | null>;
+    /**
+     * Gets principal metadata for a player.
+     */
+    getPrincipalMeta(source: number, key: string): Promise<unknown>;
+    /**
+     * Enforces access control requirements, throwing on failure.
+     *
+     * @remarks
+     * Used by RESOURCE mode to delegate security validation to CORE.
+     * Validates rank and/or permission requirements and throws if player
+     * doesn't meet the criteria.
+     *
+     * @throws AppError - AUTH:UNAUTHORIZED, GAME:NO_RANK_IN_PRINCIPAL, or AUTH:PERMISSION_DENIED
+     */
+    enforce(source: number, requirements: GuardOptions): Promise<void>;
+}

package/dist/runtime/server/controllers/principal-export.controller.js

@@ -0,0 +1,296 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrincipalExportController = void 0;
+const tsyringe_1 = require("tsyringe");
+const utils_1 = require("../../../kernel/utils");
+const index_1 = require("../contracts/index");
+const index_2 = require("../decorators/index");
+const export_1 = require("../decorators/export");
+const player_directory_port_1 = require("../services/ports/player-directory.port");
+/**
+ * Exports principal/permission functionality for RESOURCE mode access.
+ *
+ * @remarks
+ * This controller provides a complete API for remote resources to:
+ * - Query player permissions and ranks
+ * - Perform quick authorization checks
+ * - Refresh cached permissions
+ * - Query offline player permissions by account ID
+ */
+let PrincipalExportController = class PrincipalExportController {
+    constructor(playerService, principalProvider) {
+        this.playerService = playerService;
+        this.principalProvider = principalProvider;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Principal Queries
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Gets the full Principal object for a player.
+     */
+    async getPrincipal(source) {
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return null;
+        return await this.principalProvider.getPrincipal(player);
+    }
+    /**
+     * Gets Principal by account ID (works for offline players too).
+     */
+    async getPrincipalByAccountId(accountId) {
+        return await this.principalProvider.getPrincipalByLinkedID(accountId);
+    }
+    /**
+     * Forces a refresh of the player's permissions from persistence.
+     */
+    async refreshPrincipal(source) {
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return;
+        await this.principalProvider.refreshPrincipal(player);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Quick Authorization Checks
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Checks if player has a specific permission.
+     *
+     * @remarks
+     * Supports wildcard '*' permission for super-admin access.
+     */
+    async hasPermission(source, permission) {
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return false;
+        const principal = await this.principalProvider.getPrincipal(player);
+        if (!principal)
+            return false;
+        // Check for wildcard (super-admin) or specific permission
+        return principal.permissions.includes('*') || principal.permissions.includes(permission);
+    }
+    /**
+     * Checks if player has at least the required rank.
+     *
+     * @remarks
+     * Uses numeric comparison: playerRank >= requiredRank
+     */
+    async hasRank(source, requiredRank) {
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return false;
+        const principal = await this.principalProvider.getPrincipal(player);
+        if (!principal || principal.rank === undefined)
+            return false;
+        return principal.rank >= requiredRank;
+    }
+    /**
+     * Checks if player has ANY of the specified permissions.
+     */
+    async hasAnyPermission(source, permissions) {
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return false;
+        const principal = await this.principalProvider.getPrincipal(player);
+        if (!principal)
+            return false;
+        // Wildcard grants all permissions
+        if (principal.permissions.includes('*'))
+            return true;
+        return permissions.some((perm) => principal.permissions.includes(perm));
+    }
+    /**
+     * Checks if player has ALL of the specified permissions.
+     */
+    async hasAllPermissions(source, permissions) {
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return false;
+        const principal = await this.principalProvider.getPrincipal(player);
+        if (!principal)
+            return false;
+        // Wildcard grants all permissions
+        if (principal.permissions.includes('*'))
+            return true;
+        return permissions.every((perm) => principal.permissions.includes(perm));
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Property Getters
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Gets all permissions for a player.
+     */
+    async getPermissions(source) {
+        var _a;
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return [];
+        const principal = await this.principalProvider.getPrincipal(player);
+        return (_a = principal === null || principal === void 0 ? void 0 : principal.permissions) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Gets the rank value for a player.
+     */
+    async getRank(source) {
+        var _a;
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return null;
+        const principal = await this.principalProvider.getPrincipal(player);
+        return (_a = principal === null || principal === void 0 ? void 0 : principal.rank) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Gets the principal name/role name for a player.
+     */
+    async getPrincipalName(source) {
+        var _a;
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return null;
+        const principal = await this.principalProvider.getPrincipal(player);
+        return (_a = principal === null || principal === void 0 ? void 0 : principal.name) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Gets principal metadata for a player.
+     */
+    async getPrincipalMeta(source, key) {
+        var _a, _b;
+        const player = this.playerService.getByClient(source);
+        if (!player)
+            return null;
+        const principal = await this.principalProvider.getPrincipal(player);
+        return (_b = (_a = principal === null || principal === void 0 ? void 0 : principal.meta) === null || _a === void 0 ? void 0 : _a[key]) !== null && _b !== void 0 ? _b : null;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Access Control Enforcement
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Enforces access control requirements, throwing on failure.
+     *
+     * @remarks
+     * Used by RESOURCE mode to delegate security validation to CORE.
+     * Validates rank and/or permission requirements and throws if player
+     * doesn't meet the criteria.
+     *
+     * @throws AppError - AUTH:UNAUTHORIZED, GAME:NO_RANK_IN_PRINCIPAL, or AUTH:PERMISSION_DENIED
+     */
+    async enforce(source, requirements) {
+        const player = this.playerService.getByClient(source);
+        if (!player) {
+            throw new utils_1.AppError('GAME:PLAYER_NOT_FOUND', `Player not found: ${source}`, 'core');
+        }
+        if (requirements.rank !== undefined) {
+            const principal = await this.principalProvider.getPrincipal(player);
+            if (!principal) {
+                throw new utils_1.AppError('AUTH:UNAUTHORIZED', 'No principal found', 'core');
+            }
+            if (principal.rank === undefined) {
+                throw new utils_1.AppError('GAME:NO_RANK_IN_PRINCIPAL', "You're trying to compare a Principal rank, but there's no defined rank!", 'core');
+            }
+            if (principal.rank < requirements.rank) {
+                throw new utils_1.AppError('AUTH:PERMISSION_DENIED', `Access Denied: Requires minimum rank level ${requirements.rank}`, 'core');
+            }
+        }
+        if (requirements.permission) {
+            const principal = await this.principalProvider.getPrincipal(player);
+            if (!principal) {
+                throw new utils_1.AppError('AUTH:PERMISSION_DENIED', `Access Denied: Missing required permission '${requirements.permission}'`, 'core');
+            }
+            const hasPerm = principal.permissions.includes('*') ||
+                principal.permissions.includes(requirements.permission);
+            if (!hasPerm) {
+                throw new utils_1.AppError('AUTH:PERMISSION_DENIED', `Access Denied: Missing required permission '${requirements.permission}'`, 'core');
+            }
+        }
+    }
+};
+exports.PrincipalExportController = PrincipalExportController;
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "getPrincipal", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "getPrincipalByAccountId", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "refreshPrincipal", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "hasPermission", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "hasRank", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Array]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "hasAnyPermission", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Array]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "hasAllPermissions", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "getPermissions", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "getRank", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "getPrincipalName", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "getPrincipalMeta", null);
+__decorate([
+    (0, export_1.Export)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Object]),
+    __metadata("design:returntype", Promise)
+], PrincipalExportController.prototype, "enforce", null);
+exports.PrincipalExportController = PrincipalExportController = __decorate([
+    (0, index_2.Controller)(),
+    __param(1, (0, tsyringe_1.inject)(index_1.PrincipalProviderContract)),
+    __metadata("design:paramtypes", [player_directory_port_1.PlayerDirectoryPort,
+        index_1.PrincipalProviderContract])
+], PrincipalExportController);

package/dist/runtime/server/controllers/remote-command-execution.controller.d.ts

@@ -0,0 +1,43 @@
+import { IEngineEvents } from '../../../adapters/contracts/IEngineEvents';
+import { IResourceInfo } from '../../../adapters/contracts/IResourceInfo';
+import { CommandExecutionPort } from '../services/ports/command-execution.port';
+import { PlayerDirectoryPort } from '../services/ports/player-directory.port';
+/**
+ * Controller for executing remote commands in RESOURCE mode.
+ *
+ * @remarks
+ * Listens for command execution events from CORE and invokes
+ * the local handler stored in RemoteCommandService.
+ *
+ * Flow:
+ * 1. Player executes command → sent to CORE
+ * 2. CORE validates and emits local event to owning resource
+ * 3. This controller receives event → looks up handler → executes
+ *
+ * @note Uses IEngineEvents.on() (local event) not @OnNet (network event)
+ * because CORE→RESOURCE communication is server-to-server.
+ * Event registration happens in constructor via adapter layer.
+ */
+export declare class RemoteCommandExecutionController {
+    private commandService;
+    private playerDirectory;
+    private engineEvents;
+    private resourceInfo;
+    constructor(commandService: CommandExecutionPort, playerDirectory: PlayerDirectoryPort, engineEvents: IEngineEvents, resourceInfo: IResourceInfo);
+    /**
+     * Registers the event handler for command execution from CORE.
+     *
+     * @remarks
+     * Event format: `opencore:command:execute:{resourceName}`
+     * Uses adapter layer instead of direct FiveM globals.
+     */
+    private registerEventHandler;
+    /**
+     * Handles command execution requests from CORE.
+     *
+     * @param clientID - The client ID of the player executing the command
+     * @param commandName - The command to execute
+     * @param args - Command arguments
+     */
+    private handleCommandExecution;
+}