@open-core/framework 1.0.1-beta.1

package/dist/server/container.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.di = void 0;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+exports.di = tsyringe_1.container;

package/dist/server/controllers/chat.controller.d.ts

@@ -0,0 +1,10 @@
+import { RGB } from '../../utils';
+import { PlayerService } from '../services';
+import { ChatService } from '../services/chat.service';
+export declare class ChatController {
+    private readonly chatService;
+    private readonly playerService;
+    constructor(chatService: ChatService, playerService: PlayerService);
+    apiBroadcast(message: string, author?: string, color?: RGB): void;
+    apiSendPrivate(targetId: number, message: string, author?: string): void;
+}

package/dist/server/controllers/chat.controller.js

@@ -0,0 +1,50 @@
+"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.ChatController = void 0;
+const controller_1 = require("../decorators/controller");
+const export_1 = require("../decorators/export");
+const services_1 = require("../services");
+const chat_service_1 = require("../services/chat.service");
+let ChatController = class ChatController {
+    constructor(chatService, playerService) {
+        this.chatService = chatService;
+        this.playerService = playerService;
+    }
+    apiBroadcast(message, author = 'SYSTEM', color = { r: 255, g: 255, b: 255 }) {
+        this.chatService.broadcast(message, author, color);
+    }
+    apiSendPrivate(targetId, message, author = 'Private') {
+        const player = this.playerService.getByClient(targetId);
+        if (!player) {
+            throw new Error(`Player with client ID ${targetId} not found`);
+        }
+        this.chatService.sendPrivate(player, message, author);
+    }
+};
+exports.ChatController = ChatController;
+__decorate([
+    (0, export_1.Export)('core:broadcast'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", void 0)
+], ChatController.prototype, "apiBroadcast", null);
+__decorate([
+    (0, export_1.Export)('core:sendprivate'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String, String]),
+    __metadata("design:returntype", void 0)
+], ChatController.prototype, "apiSendPrivate", null);
+exports.ChatController = ChatController = __decorate([
+    (0, controller_1.Controller)(),
+    __metadata("design:paramtypes", [chat_service_1.ChatService,
+        services_1.PlayerService])
+], ChatController);

package/dist/server/controllers/command.controller.d.ts

@@ -0,0 +1,7 @@
+import { CommandService } from '../services/command.service';
+import { Player } from '../entities';
+export declare class CommandNetworkController {
+    private readonly commandService;
+    constructor(commandService: CommandService);
+    onCommandReceived(player: Player, commandName: string, args: string[], raw: string): Promise<void>;
+}

package/dist/server/controllers/command.controller.js

@@ -0,0 +1,47 @@
+"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.CommandNetworkController = void 0;
+const netEvent_1 = require("../decorators/netEvent");
+const command_service_1 = require("../services/command.service");
+const entities_1 = require("../entities");
+const decorators_1 = require("../decorators");
+const logger_1 = require("../../shared/logger");
+let CommandNetworkController = class CommandNetworkController {
+    constructor(commandService) {
+        this.commandService = commandService;
+    }
+    async onCommandReceived(player, commandName, args, raw) {
+        try {
+            logger_1.loggers.command.trace(`Received: /${commandName}`, {
+                playerId: player.clientID,
+                playerName: player.name,
+            });
+            await this.commandService.execute(player, commandName, args, raw);
+        }
+        catch (error) {
+            logger_1.loggers.command.error(`Execution failed: /${commandName}`, {
+                playerId: player.clientID,
+            }, error);
+        }
+    }
+};
+exports.CommandNetworkController = CommandNetworkController;
+__decorate([
+    (0, netEvent_1.OnNet)('core:internal:executeCommand'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [entities_1.Player, String, Array, String]),
+    __metadata("design:returntype", Promise)
+], CommandNetworkController.prototype, "onCommandReceived", null);
+exports.CommandNetworkController = CommandNetworkController = __decorate([
+    (0, decorators_1.Controller)(),
+    __metadata("design:paramtypes", [command_service_1.CommandService])
+], CommandNetworkController);

package/dist/server/core.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/server/core.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const bootstrap_1 = require("./bootstrap");
+async function init() {
+    await (0, bootstrap_1.initServer)();
+}

package/dist/server/database/adapters/oxmysql.adapter.d.ts

@@ -0,0 +1,89 @@
+/**
+ * OxMySQL Adapter
+ *
+ * Default database adapter using oxmysql resource for FiveM.
+ * Requires oxmysql to be installed and running on the server.
+ *
+ * @see https://github.com/overextended/oxmysql
+ * @see https://coxdocs.dev/oxmysql/Functions/transaction
+ */
+import { DatabaseContract } from '../database.contract';
+import type { ExecuteResult, InsertResult, TransactionInput, TransactionSharedParams } from '../types';
+/**
+ * OxMySQL Database Adapter
+ *
+ * Implements DatabaseContract using oxmysql exports.
+ *
+ * @example
+ * ```typescript
+ * import { OxMySQLAdapter } from '@open-core/framework/server'
+ *
+ * // Usually you don't need to instantiate directly,
+ * // use DatabaseService instead
+ * const adapter = new OxMySQLAdapter()
+ * const users = await adapter.query('SELECT * FROM users')
+ * ```
+ */
+export declare class OxMySQLAdapter extends DatabaseContract {
+    private ox;
+    constructor();
+    /**
+     * Execute a query and return all matching rows
+     */
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    /**
+     * Execute a query and return a single row
+     */
+    single<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    /**
+     * Execute a query and return a single scalar value
+     */
+    scalar<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    /**
+     * Execute an UPDATE or DELETE statement
+     */
+    execute(sql: string, params?: any[]): Promise<ExecuteResult>;
+    /**
+     * Execute an INSERT statement
+     */
+    insert(sql: string, params?: any[]): Promise<InsertResult>;
+    /**
+     * Execute multiple queries within a transaction.
+     *
+     * Supports three formats:
+     *
+     * **1. Specific format (object)**
+     * ```typescript
+     * await db.transaction([
+     *   { query: 'INSERT INTO test (id) VALUES (?)', values: [1] },
+     *   { query: 'INSERT INTO test (id, name) VALUES (?, ?)', values: [2, 'bob'] },
+     * ])
+     * ```
+     *
+     * **2. Specific format (tuple)**
+     * ```typescript
+     * await db.transaction([
+     *   ['INSERT INTO test (id) VALUES (?)', [1]],
+     *   ['INSERT INTO test (id, name) VALUES (?, ?)', [2, 'bob']],
+     * ])
+     * ```
+     *
+     * **3. Shared format (named parameters)**
+     * ```typescript
+     * await db.transaction(
+     *   [
+     *     'INSERT INTO test (id, name) VALUES (@someid, @somename)',
+     *     'UPDATE test SET name = @newname WHERE id = @someid',
+     *   ],
+     *   {
+     *     someid: 2,
+     *     somename: 'John Doe',
+     *     newname: 'John Notdoe',
+     *   }
+     * )
+     * ```
+     *
+     * @see https://coxdocs.dev/oxmysql/Functions/transaction
+     */
+    transaction(queries: TransactionInput, sharedParams?: TransactionSharedParams): Promise<boolean>;
+}

package/dist/server/database/adapters/oxmysql.adapter.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * OxMySQL Adapter
+ *
+ * Default database adapter using oxmysql resource for FiveM.
+ * Requires oxmysql to be installed and running on the server.
+ *
+ * @see https://github.com/overextended/oxmysql
+ * @see https://coxdocs.dev/oxmysql/Functions/transaction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxMySQLAdapter = void 0;
+const database_contract_1 = require("../database.contract");
+/**
+ * Get the oxmysql export from FiveM
+ */
+function getOxMySQL() {
+    const ox = global.exports['oxmysql'];
+    if (!ox) {
+        throw new Error('[OpenCore] oxmysql is not available. Make sure oxmysql resource is started before your resource.');
+    }
+    return ox;
+}
+/**
+ * Normalize transaction input to oxmysql format
+ */
+function normalizeQueries(queries) {
+    if (queries.length === 0)
+        return [];
+    const first = queries[0];
+    // String array - used with shared params
+    if (typeof first === 'string') {
+        return queries;
+    }
+    // Tuple format: [query, values]
+    if (Array.isArray(first)) {
+        return queries.map(([query, values]) => ({
+            query,
+            values,
+        }));
+    }
+    // Already in TransactionQuery format
+    return queries;
+}
+/**
+ * OxMySQL Database Adapter
+ *
+ * Implements DatabaseContract using oxmysql exports.
+ *
+ * @example
+ * ```typescript
+ * import { OxMySQLAdapter } from '@open-core/framework/server'
+ *
+ * // Usually you don't need to instantiate directly,
+ * // use DatabaseService instead
+ * const adapter = new OxMySQLAdapter()
+ * const users = await adapter.query('SELECT * FROM users')
+ * ```
+ */
+class OxMySQLAdapter extends database_contract_1.DatabaseContract {
+    constructor() {
+        super();
+        this.ox = getOxMySQL();
+    }
+    /**
+     * Execute a query and return all matching rows
+     */
+    async query(sql, params) {
+        const result = await this.ox.query_async(sql, params);
+        return result !== null && result !== void 0 ? result : [];
+    }
+    /**
+     * Execute a query and return a single row
+     */
+    async single(sql, params) {
+        const result = await this.ox.single_async(sql, params);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    /**
+     * Execute a query and return a single scalar value
+     */
+    async scalar(sql, params) {
+        const result = await this.ox.scalar_async(sql, params);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    /**
+     * Execute an UPDATE or DELETE statement
+     */
+    async execute(sql, params) {
+        const affectedRows = await this.ox.update_async(sql, params);
+        return { affectedRows: affectedRows !== null && affectedRows !== void 0 ? affectedRows : 0 };
+    }
+    /**
+     * Execute an INSERT statement
+     */
+    async insert(sql, params) {
+        const insertId = await this.ox.insert_async(sql, params);
+        return { insertId: insertId !== null && insertId !== void 0 ? insertId : 0 };
+    }
+    /**
+     * Execute multiple queries within a transaction.
+     *
+     * Supports three formats:
+     *
+     * **1. Specific format (object)**
+     * ```typescript
+     * await db.transaction([
+     *   { query: 'INSERT INTO test (id) VALUES (?)', values: [1] },
+     *   { query: 'INSERT INTO test (id, name) VALUES (?, ?)', values: [2, 'bob'] },
+     * ])
+     * ```
+     *
+     * **2. Specific format (tuple)**
+     * ```typescript
+     * await db.transaction([
+     *   ['INSERT INTO test (id) VALUES (?)', [1]],
+     *   ['INSERT INTO test (id, name) VALUES (?, ?)', [2, 'bob']],
+     * ])
+     * ```
+     *
+     * **3. Shared format (named parameters)**
+     * ```typescript
+     * await db.transaction(
+     *   [
+     *     'INSERT INTO test (id, name) VALUES (@someid, @somename)',
+     *     'UPDATE test SET name = @newname WHERE id = @someid',
+     *   ],
+     *   {
+     *     someid: 2,
+     *     somename: 'John Doe',
+     *     newname: 'John Notdoe',
+     *   }
+     * )
+     * ```
+     *
+     * @see https://coxdocs.dev/oxmysql/Functions/transaction
+     */
+    async transaction(queries, sharedParams) {
+        if (queries.length === 0)
+            return true;
+        const normalizedQueries = normalizeQueries(queries);
+        // Use shared params format if provided
+        if (sharedParams) {
+            return await this.ox.transaction_async(normalizedQueries, sharedParams);
+        }
+        return await this.ox.transaction_async(normalizedQueries);
+    }
+}
+exports.OxMySQLAdapter = OxMySQLAdapter;

package/dist/server/database/database.contract.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Database Contract
+ *
+ * Abstract base class that defines the interface for all database adapters.
+ * Implement this contract to create custom database adapters.
+ *
+ * @example
+ * ```typescript
+ * class MyDatabaseAdapter extends DatabaseContract {
+ *   async query<T>(sql: string, params?: any[]): Promise<T[]> {
+ *     // Implementation
+ *   }
+ *   // ... other methods
+ * }
+ * ```
+ */
+import type { ExecuteResult, InsertResult, TransactionInput, TransactionSharedParams } from './types';
+/**
+ * Abstract contract for database adapters.
+ *
+ * All database adapters must extend this class and implement
+ * all abstract methods to ensure consistent behavior across
+ * different database backends.
+ */
+export declare abstract class DatabaseContract {
+    /**
+     * Execute a query and return all matching rows.
+     *
+     * @param sql - The SQL query string
+     * @param params - Optional parameters for prepared statement
+     * @returns Array of results
+     *
+     * @example
+     * ```typescript
+     * const users = await db.query<User>('SELECT * FROM users WHERE active = ?', [true])
+     * ```
+     */
+    abstract query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    /**
+     * Execute a query and return a single row.
+     *
+     * @param sql - The SQL query string
+     * @param params - Optional parameters for prepared statement
+     * @returns Single result or null if not found
+     *
+     * @example
+     * ```typescript
+     * const user = await db.single<User>('SELECT * FROM users WHERE id = ?', [userId])
+     * if (user) {
+     *   console.log(user.name)
+     * }
+     * ```
+     */
+    abstract single<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    /**
+     * Execute a query and return a single scalar value.
+     *
+     * @param sql - The SQL query string
+     * @param params - Optional parameters for prepared statement
+     * @returns Scalar value or null if not found
+     *
+     * @example
+     * ```typescript
+     * const count = await db.scalar<number>('SELECT COUNT(*) FROM users')
+     * const name = await db.scalar<string>('SELECT name FROM users WHERE id = ?', [userId])
+     * ```
+     */
+    abstract scalar<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    /**
+     * Execute an UPDATE or DELETE statement.
+     *
+     * @param sql - The SQL statement
+     * @param params - Optional parameters for prepared statement
+     * @returns Object containing affected rows count
+     *
+     * @example
+     * ```typescript
+     * const result = await db.execute('UPDATE users SET active = ? WHERE id = ?', [false, userId])
+     * console.log(`Updated ${result.affectedRows} rows`)
+     * ```
+     */
+    abstract execute(sql: string, params?: any[]): Promise<ExecuteResult>;
+    /**
+     * Execute an INSERT statement.
+     *
+     * @param sql - The SQL insert statement
+     * @param params - Optional parameters for prepared statement
+     * @returns Object containing the inserted row ID
+     *
+     * @example
+     * ```typescript
+     * const result = await db.insert('INSERT INTO users (name, email) VALUES (?, ?)', ['John', 'john@example.com'])
+     * console.log(`Inserted user with ID: ${result.insertId}`)
+     * ```
+     */
+    abstract insert(sql: string, params?: any[]): Promise<InsertResult>;
+    /**
+     * Execute multiple queries within a transaction.
+     *
+     * All queries are committed together if all succeed, or rolled back if any fails.
+     *
+     * **Specific format** - Each query has its own parameters:
+     * ```typescript
+     * await db.transaction([
+     *   { query: 'INSERT INTO users (name) VALUES (?)', values: ['John'] },
+     *   { query: 'INSERT INTO logs (action) VALUES (?)', values: ['user_created'] },
+     * ])
+     * ```
+     *
+     * **Shared format** - All queries share named parameters:
+     * ```typescript
+     * await db.transaction(
+     *   [
+     *     'INSERT INTO users (id, name) VALUES (@userid, @username)',
+     *     'INSERT INTO profiles (user_id) VALUES (@userid)',
+     *   ],
+     *   { userid: 1, username: 'John' }
+     * )
+     * ```
+     *
+     * @param queries - Array of queries to execute
+     * @param sharedParams - Optional shared parameters for all queries (named params format)
+     * @returns true if transaction succeeded, false otherwise
+     *
+     * @see https://coxdocs.dev/oxmysql/Functions/transaction
+     */
+    abstract transaction(queries: TransactionInput, sharedParams?: TransactionSharedParams): Promise<boolean>;
+}

package/dist/server/database/database.contract.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Database Contract
+ *
+ * Abstract base class that defines the interface for all database adapters.
+ * Implement this contract to create custom database adapters.
+ *
+ * @example
+ * ```typescript
+ * class MyDatabaseAdapter extends DatabaseContract {
+ *   async query<T>(sql: string, params?: any[]): Promise<T[]> {
+ *     // Implementation
+ *   }
+ *   // ... other methods
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseContract = void 0;
+/**
+ * Abstract contract for database adapters.
+ *
+ * All database adapters must extend this class and implement
+ * all abstract methods to ensure consistent behavior across
+ * different database backends.
+ */
+class DatabaseContract {
+}
+exports.DatabaseContract = DatabaseContract;