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

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

@@ -0,0 +1,104 @@
+"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.RemoteCommandExecutionController = void 0;
+const tsyringe_1 = require("tsyringe");
+const IEngineEvents_1 = require("../../../adapters/contracts/IEngineEvents");
+const IResourceInfo_1 = require("../../../adapters/contracts/IResourceInfo");
+const kernel_1 = require("../../../kernel");
+const logger_1 = require("../../../kernel/shared/logger");
+const decorators_1 = require("../decorators");
+const command_execution_port_1 = require("../services/ports/command-execution.port");
+const player_directory_port_1 = require("../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.
+ */
+let RemoteCommandExecutionController = class RemoteCommandExecutionController {
+    constructor(commandService, playerDirectory, engineEvents, resourceInfo) {
+        this.commandService = commandService;
+        this.playerDirectory = playerDirectory;
+        this.engineEvents = engineEvents;
+        this.resourceInfo = resourceInfo;
+        this.registerEventHandler();
+    }
+    /**
+     * Registers the event handler for command execution from CORE.
+     *
+     * @remarks
+     * Event format: `opencore:command:execute:{resourceName}`
+     * Uses adapter layer instead of direct FiveM globals.
+     */
+    registerEventHandler() {
+        const resourceName = this.resourceInfo.getCurrentResourceName();
+        const eventName = `opencore:command:execute:${resourceName}`;
+        this.engineEvents.on(eventName, async (clientID, commandName, args) => {
+            await this.handleCommandExecution(clientID, commandName, args);
+        });
+        logger_1.loggers.command.debug(`Registered remote command handler for resource: ${resourceName}`);
+    }
+    /**
+     * 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
+     */
+    async handleCommandExecution(clientID, commandName, args) {
+        const player = this.playerDirectory.getByClient(clientID);
+        if (!player) {
+            logger_1.loggers.command.warn(`Command execution failed: player not found`, {
+                command: commandName,
+                clientID,
+            });
+            return;
+        }
+        try {
+            await this.commandService.execute(player, commandName, args);
+        }
+        catch (error) {
+            if (error instanceof kernel_1.AppError) {
+                player.send(error.message);
+            }
+            logger_1.loggers.command.error(`Remote command execution failed`, {
+                command: commandName,
+                clientID: player.clientID,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+};
+exports.RemoteCommandExecutionController = RemoteCommandExecutionController;
+exports.RemoteCommandExecutionController = RemoteCommandExecutionController = __decorate([
+    (0, tsyringe_1.injectable)(),
+    (0, decorators_1.Controller)(),
+    __param(2, (0, tsyringe_1.inject)(IEngineEvents_1.IEngineEvents)),
+    __param(3, (0, tsyringe_1.inject)(IResourceInfo_1.IResourceInfo)),
+    __metadata("design:paramtypes", [command_execution_port_1.CommandExecutionPort,
+        player_directory_port_1.PlayerDirectoryPort,
+        IEngineEvents_1.IEngineEvents,
+        IResourceInfo_1.IResourceInfo])
+], RemoteCommandExecutionController);

package/dist/runtime/server/controllers/session.controller.d.ts

@@ -0,0 +1,11 @@
+import { PlayerDirectoryPort } from '../services';
+import { PlayerPersistenceService } from '../services/persistence.service';
+import { PlayerSessionLifecyclePort } from '../services/ports/player-session-lifecycle.port';
+export declare class SessionController {
+    private readonly playerSessionLifecycle;
+    private readonly playerDirectory;
+    private readonly persistance;
+    constructor(playerSessionLifecycle: PlayerSessionLifecyclePort, playerDirectory: PlayerDirectoryPort, persistance: PlayerPersistenceService);
+    onPlayerJoining(): Promise<void>;
+    onPlayerDropped(): Promise<void>;
+}

package/dist/{server → runtime/server}/controllers/session.controller.js

@@ -10,43 +10,45 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionController = void 0;
-const shared_1 = require("../../shared");
+const shared_1 = require("../../../kernel/shared");
 const core_event_bus_1 = require("../bus/core-event-bus");
 const decorators_1 = require("../decorators");
 const onFiveMEvent_1 = require("../decorators/onFiveMEvent");
 const services_1 = require("../services");
 const persistence_service_1 = require("../services/persistence.service");
+const player_session_lifecycle_port_1 = require("../services/ports/player-session-lifecycle.port");
 let SessionController = class SessionController {
-    constructor(playerManager, persistance) {
-        this.playerManager = playerManager;
+    constructor(playerSessionLifecycle, playerDirectory, persistance) {
+        this.playerSessionLifecycle = playerSessionLifecycle;
+        this.playerDirectory = playerDirectory;
         this.persistance = persistance;
     }
     async onPlayerJoining() {
         var _a;
-        const clientId = source;
+        const clientId = Number(source);
         const license = (_a = GetPlayerIdentifier(clientId.toString(), 0)) !== null && _a !== void 0 ? _a : undefined;
-        const player = this.playerManager.bind(clientId, { license });
+        const player = this.playerSessionLifecycle.bind(clientId, { license });
         shared_1.loggers.session.info(`Player session created`, {
             clientId,
             license: license !== null && license !== void 0 ? license : 'none',
         });
         await this.persistance.handleSessionLoad(player);
-        (0, core_event_bus_1.emitCoreEvent)('core:playerSessionCreated', { clientId, license });
+        (0, core_event_bus_1.emitFrameworkEvent)('core:playerSessionCreated', { clientId, license });
         setImmediate(() => {
-            const currentPlayer = this.playerManager.getByClient(clientId);
+            const currentPlayer = this.playerDirectory.getByClient(clientId);
             if (!currentPlayer)
                 return;
-            (0, core_event_bus_1.emitCoreEvent)('core:playerFullyConnected', { clientId, license });
+            (0, core_event_bus_1.emitFrameworkEvent)('core:playerFullyConnected', { clientId, license });
         });
     }
     async onPlayerDropped() {
         const clientId = Number(source);
-        const player = this.playerManager.getByClient(clientId);
+        const player = this.playerDirectory.getByClient(clientId);
         if (player) {
             await this.persistance.handleSessionSave(player);
         }
-        this.playerManager.unbindByClient(clientId);
-        (0, core_event_bus_1.emitCoreEvent)('core:playerSessionDestroyed', { clientId });
+        this.playerSessionLifecycle.unbind(clientId);
+        (0, core_event_bus_1.emitFrameworkEvent)('core:playerSessionDestroyed', { clientId });
         shared_1.loggers.session.info(`Player session destroyed`, { clientId });
     }
 };
@@ -65,6 +67,7 @@ __decorate([
 ], SessionController.prototype, "onPlayerDropped", null);
 exports.SessionController = SessionController = __decorate([
     (0, decorators_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.PlayerService,
+    __metadata("design:paramtypes", [player_session_lifecycle_port_1.PlayerSessionLifecyclePort,
+        services_1.PlayerDirectoryPort,
         persistence_service_1.PlayerPersistenceService])
 ], SessionController);

package/dist/runtime/server/controllers/vehicle.controller.d.ts

@@ -0,0 +1,55 @@
+import { Player } from '../entities/player';
+import { VehicleService } from '../services/vehicle.service';
+import { VehicleModificationService } from '../services/vehicle-modification.service';
+import { VehicleCreateOptions, VehicleModificationOptions } from '../types/vehicle.types';
+/**
+ * Controller for handling vehicle-related network events.
+ *
+ * All client requests for vehicle operations go through this controller
+ * for validation and security checks.
+ */
+export declare class VehicleController {
+    private readonly vehicleService;
+    private readonly modificationService;
+    constructor(vehicleService: VehicleService, modificationService: VehicleModificationService);
+    /**
+     * Handles client request to create a vehicle.
+     */
+    handleCreateVehicle(player: Player, options: VehicleCreateOptions): Promise<import("../types/vehicle.types").VehicleSpawnResult>;
+    /**
+     * Handles client request to delete a vehicle.
+     */
+    handleDeleteVehicle(player: Player, networkId: number): boolean;
+    /**
+     * Handles client request to modify a vehicle.
+     */
+    handleModifyVehicle(player: Player, options: VehicleModificationOptions): boolean;
+    /**
+     * Handles client request to repair a vehicle.
+     */
+    handleRepairVehicle(player: Player, networkId: number): boolean;
+    /**
+     * Handles client request to set vehicle fuel.
+     */
+    handleSetFuel(player: Player, networkId: number, level: number): boolean;
+    /**
+     * Handles client request to lock/unlock vehicle doors.
+     */
+    handleSetLocked(player: Player, networkId: number, locked: boolean): boolean;
+    /**
+     * Handles client request to get vehicle data.
+     */
+    handleGetData(player: Player, networkId: number): import("../types/vehicle.types").SerializedVehicleData | null;
+    /**
+     * Handles client request to get all player vehicles.
+     */
+    handleGetPlayerVehicles(player: Player): import("../types/vehicle.types").SerializedVehicleData[];
+    /**
+     * Handles client request to teleport a vehicle.
+     */
+    handleTeleport(player: Player, networkId: number, position: {
+        x: number;
+        y: number;
+        z: number;
+    }, heading?: number): boolean;
+}

package/dist/runtime/server/controllers/vehicle.controller.js

@@ -0,0 +1,216 @@
+"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.VehicleController = void 0;
+const tsyringe_1 = require("tsyringe");
+const logger_1 = require("../../../kernel/shared/logger");
+const decorators_1 = require("../decorators");
+const player_1 = require("../entities/player");
+const vehicle_service_1 = require("../services/vehicle.service");
+const vehicle_modification_service_1 = require("../services/vehicle-modification.service");
+/**
+ * Controller for handling vehicle-related network events.
+ *
+ * All client requests for vehicle operations go through this controller
+ * for validation and security checks.
+ */
+let VehicleController = class VehicleController {
+    constructor(vehicleService, modificationService) {
+        this.vehicleService = vehicleService;
+        this.modificationService = modificationService;
+    }
+    /**
+     * Handles client request to create a vehicle.
+     */
+    async handleCreateVehicle(player, options) {
+        const source = player.clientID;
+        logger_1.coreLogger.debug('Vehicle creation requested', { clientID: source, options });
+        const result = await this.vehicleService.createForPlayer(source, options);
+        emitNet('opencore:vehicle:createResult', source, result);
+        return result;
+    }
+    /**
+     * Handles client request to delete a vehicle.
+     */
+    handleDeleteVehicle(player, networkId) {
+        const source = player.clientID;
+        logger_1.coreLogger.debug('Vehicle deletion requested', { clientID: source, networkId });
+        const success = this.vehicleService.delete(networkId, source);
+        emitNet('opencore:vehicle:deleteResult', source, { networkId, success });
+        return success;
+    }
+    /**
+     * Handles client request to modify a vehicle.
+     */
+    handleModifyVehicle(player, options) {
+        const source = player.clientID;
+        logger_1.coreLogger.debug('Vehicle modification requested', { clientID: source, options });
+        const success = this.modificationService.applyModifications(Object.assign(Object.assign({}, options), { requestedBy: source }));
+        emitNet('opencore:vehicle:modifyResult', source, { networkId: options.networkId, success });
+        return success;
+    }
+    /**
+     * Handles client request to repair a vehicle.
+     */
+    handleRepairVehicle(player, networkId) {
+        const source = player.clientID;
+        logger_1.coreLogger.debug('Vehicle repair requested', { clientID: source, networkId });
+        if (!this.vehicleService.validateOwnership(networkId, source)) {
+            emitNet('opencore:vehicle:repairResult', source, { networkId, success: false });
+            return false;
+        }
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle) {
+            emitNet('opencore:vehicle:repairResult', source, { networkId, success: false });
+            return false;
+        }
+        emitNet('opencore:vehicle:repairResult', source, { networkId, success: true });
+        emitNet('opencore:vehicle:repaired', -1, networkId);
+        return true;
+    }
+    /**
+     * Handles client request to set vehicle fuel.
+     */
+    handleSetFuel(player, networkId, level) {
+        const source = player.clientID;
+        if (!this.vehicleService.validateOwnership(networkId, source)) {
+            return false;
+        }
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle)
+            return false;
+        vehicle.setFuel(level);
+        return true;
+    }
+    /**
+     * Handles client request to lock/unlock vehicle doors.
+     */
+    handleSetLocked(player, networkId, locked) {
+        const source = player.clientID;
+        if (!this.vehicleService.validateOwnership(networkId, source)) {
+            return false;
+        }
+        if (!this.vehicleService.validateProximity(networkId, source, 10.0)) {
+            return false;
+        }
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle)
+            return false;
+        vehicle.setDoorsLocked(locked);
+        emitNet('opencore:vehicle:lockedChanged', -1, { networkId, locked });
+        return true;
+    }
+    /**
+     * Handles client request to get vehicle data.
+     */
+    handleGetData(player, networkId) {
+        const source = player.clientID;
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle) {
+            emitNet('opencore:vehicle:dataResult', source, null);
+            return null;
+        }
+        const data = vehicle.serialize();
+        emitNet('opencore:vehicle:dataResult', source, data);
+        return data;
+    }
+    /**
+     * Handles client request to get all player vehicles.
+     */
+    handleGetPlayerVehicles(player) {
+        const source = player.clientID;
+        const vehicles = this.vehicleService.getPlayerVehicles(source);
+        const serialized = vehicles.map((v) => v.serialize());
+        emitNet('opencore:vehicle:playerVehiclesResult', source, serialized);
+        return serialized;
+    }
+    /**
+     * Handles client request to teleport a vehicle.
+     */
+    handleTeleport(player, networkId, position, heading) {
+        const source = player.clientID;
+        if (!this.vehicleService.validateOwnership(networkId, source)) {
+            return false;
+        }
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle)
+            return false;
+        vehicle.teleport(position, heading);
+        emitNet('opencore:vehicle:teleported', -1, { networkId, position, heading });
+        return true;
+    }
+};
+exports.VehicleController = VehicleController;
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:create'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Object]),
+    __metadata("design:returntype", Promise)
+], VehicleController.prototype, "handleCreateVehicle", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:delete'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Number]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleDeleteVehicle", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:modify'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Object]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleModifyVehicle", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:repair'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Number]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleRepairVehicle", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:setFuel'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Number, Number]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleSetFuel", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:setLocked'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Number, Boolean]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleSetLocked", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:getData'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Number]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleGetData", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:getPlayerVehicles'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleGetPlayerVehicles", null);
+__decorate([
+    (0, decorators_1.OnNet)('opencore:vehicle:teleport'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [player_1.Player, Number, Object, Number]),
+    __metadata("design:returntype", void 0)
+], VehicleController.prototype, "handleTeleport", null);
+exports.VehicleController = VehicleController = __decorate([
+    (0, decorators_1.Controller)(),
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(vehicle_service_1.VehicleService)),
+    __param(1, (0, tsyringe_1.inject)(vehicle_modification_service_1.VehicleModificationService)),
+    __metadata("design:paramtypes", [vehicle_service_1.VehicleService,
+        vehicle_modification_service_1.VehicleModificationService])
+], VehicleController);

package/dist/runtime/server/core.d.ts

@@ -0,0 +1,3 @@
+import { type FrameworkMode, type ServerInitOptions } from './runtime';
+export declare let _mode: FrameworkMode;
+export declare function init(options: ServerInitOptions): Promise<void>;

package/dist/runtime/server/core.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._mode = void 0;
+exports.init = init;
+const bootstrap_1 = require("./bootstrap");
+const runtime_1 = require("./runtime");
+async function init(options) {
+    const resolved = (0, runtime_1.resolveRuntimeOptions)(options);
+    exports._mode = resolved.mode;
+    await (0, bootstrap_1.initServer)(resolved);
+}

package/dist/runtime/server/database/adapter.registry.d.ts

@@ -0,0 +1,4 @@
+import { DatabaseContract } from './database.contract';
+export type DatabaseAdapterFactoryFn = () => DatabaseContract;
+export declare function registerDatabaseAdapterFactory(name: string, factory: DatabaseAdapterFactoryFn): void;
+export declare function resolveDatabaseAdapterFactory(name: string): DatabaseAdapterFactoryFn | undefined;

package/dist/runtime/server/database/adapter.registry.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDatabaseAdapterFactory = registerDatabaseAdapterFactory;
+exports.resolveDatabaseAdapterFactory = resolveDatabaseAdapterFactory;
+const factories = new Map();
+function registerDatabaseAdapterFactory(name, factory) {
+    if (factories.has(name)) {
+        throw new Error(`[OpenCore] Database adapter factory '${name}' is already registered`);
+    }
+    factories.set(name, factory);
+}
+function resolveDatabaseAdapterFactory(name) {
+    return factories.get(name);
+}

package/dist/{server → runtime/server}/database/database.contract.d.ts

@@ -14,7 +14,7 @@
  * }
  * ```
  */
-import type { ExecuteResult, InsertResult, TransactionInput, TransactionSharedParams } from './types';
+import { ExecuteResult, InsertResult, TransactionInput, TransactionSharedParams } from './types';
 /**
  * Abstract contract for database adapters.
  *

package/dist/{server → runtime/server}/database/database.service.d.ts

@@ -1,35 +1,7 @@
-/**
- * Database Service
- *
- * Main entry point for database operations. Acts as a factory/wrapper
- * that delegates to the registered database adapter.
- *
- * @example
- * ```typescript
- * import { DatabaseService } from '@open-core/framework/server'
- * import { inject, injectable } from 'tsyringe'
- *
- * @injectable()
- * class UserService {
- *   constructor(@inject(DatabaseService) private db: DatabaseService) {}
- *
- *   async getUser(id: number) {
- *     return this.db.single<User>('SELECT * FROM users WHERE id = ?', [id])
- *   }
- * }
- * ```
- */
 import { DatabaseContract } from './database.contract';
-import type { DatabaseConfig, ExecuteResult, InsertResult, TransactionInput, TransactionSharedParams } from './types';
-/**
- * Database Service
- *
- * Singleton service that provides database operations through
- * a pluggable adapter system. Uses oxmysql by default.
- */
+import { DatabaseConfig, ExecuteResult, InsertResult, TransactionInput, TransactionSharedParams } from './types';
 export declare class DatabaseService extends DatabaseContract {
     private adapter;
-    private config;
     private isInitialized;
     /**
      * Initialize the database service with optional configuration
@@ -61,9 +33,9 @@ export declare class DatabaseService extends DatabaseContract {
      */
     getAdapter(): DatabaseContract;
     /**
-     * Ensure the service is initialized before operations
+     * Ensure the service is initialized and return the adapter
      */
-    private ensureInitialized;
+    private getInitializedAdapter;
     /**
      * Execute a query and return all matching rows
      */