@armoury/fivem-framework-server 0.0.0-stage → 1.0.7

package/dist/esm/server/entity-controllers/server-entity-entrance.controller.js

@@ -0,0 +1,24 @@
+// TODO: Remove
+import { isPlayerInRangeOfPoint } from '@armoury/fivem-framework-common';
+import { ServerDBDependentController } from '../server-db-dependent.controller';
+export class ServerEntityWithEntranceController extends ServerDBDependentController {
+    getClosestEntityOfSameTypeToPlayer(player) {
+        return this.getClosestEntityOfSameTypeExitToPlayer(player) || this.getClosestEntityOfSameTypeEntranceToPlayer(player);
+    }
+    getClosestEntityOfSameTypeEntranceToPlayer(source) {
+        // TODO: Replace here to actually get the closest, not the first one in the range
+        const playerPosition = Cfx.Server.GetEntityCoords(Cfx.Server.GetPlayerPed(Cfx.source.toString()) /*, true*/);
+        const entity = this.entities.find((_entity) => isPlayerInRangeOfPoint(playerPosition[0], playerPosition[1], playerPosition[2], _entity.entranceX, _entity.entranceY, _entity.entranceZ, 3.0));
+        return entity || null;
+    }
+    getClosestEntityOfSameTypeExitToPlayer(source) {
+        const virtualWorld = this.getPlayerVirtualWorld(source) || 0;
+        const entity = this.getEntityByDBId(virtualWorld);
+        const playerPosition = Cfx.Server.GetEntityCoords(Cfx.Server.GetPlayerPed(Cfx.source.toString()) /*, true*/);
+        // TODO: Replace here to actually get the closest, not the first one in the range
+        if (entity && isPlayerInRangeOfPoint(playerPosition[0], playerPosition[1], playerPosition[2], entity.exitX, entity.exitY, entity.exitZ, 3.0)) {
+            return entity;
+        }
+        return null;
+    }
+}

package/dist/esm/server/index.js

@@ -0,0 +1,64 @@
+/// <reference path = "../ambient.declarations.d.ts" />
+import 'reflect-metadata';
+import { MikroORM } from '@mikro-orm/core';
+import { ReflectiveInjector } from 'injection-js';
+import { Character, SessionAccountId, SessionCash, SessionHoursPlayed, SessionId, SessionLanguage, SessionLastLocation, SessionName } from './services/session/default-entities';
+import { Decorate } from '@armoury/fivem-framework-common';
+export const SERVER_PROVIDERS = [
+    {
+        provide: 'sessionItems',
+        useValue: new SessionId(),
+        multi: true,
+    },
+    {
+        provide: 'sessionItems',
+        useValue: new SessionAccountId(),
+        multi: true,
+    },
+    {
+        provide: 'sessionItems',
+        useValue: new SessionName(),
+        multi: true,
+    },
+    {
+        provide: 'sessionItems',
+        useValue: new SessionCash(),
+        multi: true,
+    },
+    {
+        provide: 'sessionItems',
+        useValue: new SessionHoursPlayed(),
+        multi: true,
+    },
+    {
+        provide: 'sessionItems',
+        useValue: new SessionLastLocation(),
+        multi: true,
+    },
+    {
+        provide: 'sessionItems',
+        useValue: new SessionLanguage(),
+        multi: true,
+    },
+];
+export async function Server_Init(_class, ...providers) {
+    var _a;
+    const database = (_a = Cfx.Server.GetConvar('mysql_connection_string', '').split(';')
+        .find((item) => item.startsWith('database='))) === null || _a === void 0 ? void 0 : _a.split('=').slice(-1)[0];
+    const test = await MikroORM.init({
+        baseDir: __dirname + '/../..',
+        entities: [Character],
+        // entitiesTs: ['./src/**/*.entity.ts'],
+        dbName: database,
+        discovery: { disableDynamicFileAccess: true }
+    });
+    console.log('mikro-orm is', test);
+    const mainInjector = ReflectiveInjector.resolveAndCreate(SERVER_PROVIDERS);
+    const injector = ReflectiveInjector.resolveAndCreate([...providers, _class], mainInjector);
+    const instance = injector.get(_class);
+    Decorate(instance, _class.prototype, [...SERVER_PROVIDERS, ...providers]);
+    return instance;
+}
+export * from './services';
+export * from './models';
+export * from '@armoury/fivem-framework-common';

package/dist/esm/server/models/create-vehicle.enums.js

@@ -0,0 +1,5 @@
+export var CREATE_VEHICLE_EVENT_TYPE;
+(function (CREATE_VEHICLE_EVENT_TYPE) {
+    CREATE_VEHICLE_EVENT_TYPE[CREATE_VEHICLE_EVENT_TYPE["ATTACH_TRAILER"] = 0] = "ATTACH_TRAILER";
+})(CREATE_VEHICLE_EVENT_TYPE || (CREATE_VEHICLE_EVENT_TYPE = {}));
+;

package/dist/esm/server/models/index.js

@@ -0,0 +1 @@
+export * from './session';

package/dist/esm/server/models/session/base-items/array.session-item.js

@@ -0,0 +1,56 @@
+import { SessionItem } from "../session-item.model";
+export class ArraySessionItem extends SessionItem {
+    constructor(name, value, critical = false, tableName, syncedProperties) {
+        super(name, value, critical);
+        this.tableName = tableName;
+        this.syncedProperties = syncedProperties;
+        if (!this.syncedProperties.length) {
+            this.syncedProperties.push({ name: 'value', type: 'varchar(256)' });
+        }
+        this.syncedProperties = [
+            ...DEFAULT_PROPERTIES,
+            ...syncedProperties
+        ];
+        this.setup();
+    }
+    async load(accountId, characterId) {
+        return await Cfx.exports['oxmysql'].query_async(`SELECT * FROM ${this.tableName} WHERE id=? AND accountId=?`, [characterId, accountId]);
+    }
+    async save(accountId, characterId, value) {
+        const columns = this.syncedProperties.map((prop) => prop.name).join(',');
+        const keys = value.map(() => `(${new Array(columns.length).fill(0).map(() => '?').join(', ')})`).join(', ');
+        const values = new Array(value.length).fill(0).map((_, valueIndex) => this.syncedProperties.map((prop) => {
+            if (prop.name === 'accountId') {
+                return accountId;
+            }
+            if (prop.name === 'characterId') {
+                return characterId;
+            }
+            return value[valueIndex][prop.name];
+        }))
+            .flat();
+        await Cfx.exports['oxmysql'].query_async(`DELETE FROM \`${this.tableName}\` WHERE accountId = ? AND characterId = ?`, [accountId, characterId]);
+        await Cfx.exports['oxmysql'].insert_async(`INSERT INTO \`${this.tableName}\` (${columns}) VALUES ${keys}`, values);
+    }
+    async setup() {
+        var _a;
+        const database = (_a = Cfx.Server.GetConvar('mysql_connection_string', '').split(';')
+            .find((item) => item.startsWith('database='))) === null || _a === void 0 ? void 0 : _a.split('=').slice(-1)[0];
+        const result = await Cfx.exports['oxmysql'].single_async(`SELECT EXISTS (
+                SELECT 1
+                FROM information_schema.tables 
+                WHERE table_schema = '${database}' 
+                AND table_name = '${this.tableName}'
+            ) AS table_exists;`);
+        if (!result.table_exists) {
+            // TODO: Create table
+        }
+        else {
+            // TODO: Do migrations
+        }
+    }
+}
+const DEFAULT_PROPERTIES = [
+    { name: 'accountId', type: 'int(11)' },
+    { name: 'characterId', type: 'int(11)' },
+];

package/dist/esm/server/models/session/base-items/index.js

@@ -0,0 +1 @@
+export * from './array.session-item';

package/dist/esm/server/models/session/index.js

@@ -0,0 +1,3 @@
+export * from './base-items';
+export * from './session-item.model';
+export * from './session.model';

package/dist/esm/server/models/session/session-item.model.js

@@ -0,0 +1,15 @@
+export class SessionItem {
+    constructor(name, defaultValue, critical = false) {
+        this.name = name;
+        this.defaultValue = defaultValue;
+        this.critical = critical;
+    }
+    load(_accountId, _characterId, bruteValue) {
+        return Promise.resolve(!Number.isNaN(Number(bruteValue))
+            ? Number(bruteValue)
+            : bruteValue);
+    }
+    compute(_playerId, originalValue) {
+        return originalValue;
+    }
+}

package/dist/esm/server/models/session/session.model.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/server/server-db-dependent.controller.js

@@ -0,0 +1,224 @@
+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);
+};
+// TODO: Remove
+import { ServerController } from "./server.controller";
+import { isJSON, Controller, EventListener, Export } from '@armoury/fivem-framework-common';
+let ServerDBDependentController = class ServerDBDependentController extends ServerController {
+    get entities() {
+        return this._entities;
+    }
+    get cachedProperties() {
+        return this._cachedProperties;
+    }
+    get playerToEntityBindings() {
+        return this._playerToEntityBindings;
+    }
+    constructor(dbTableName, loadAllAtStart = false) {
+        super();
+        this.dbTableName = dbTableName;
+        this._entities = [];
+        this._cachedProperties = [];
+        this._playerToEntityBindings = new Map();
+        this.computeTableProperties();
+        if (loadAllAtStart) {
+            this.loadDBEntities();
+        }
+    }
+    getEntities() {
+        return this._entities;
+    }
+    createEntity(entity, forceId) {
+        return (async () => {
+            try {
+                let entityProperties = this.getEntityProperties(entity);
+                let entityValues = this.getEntityPropertiesValues(entity, entityProperties);
+                if (forceId) {
+                    entityProperties = ['id', ...entityProperties];
+                    entityValues = [forceId.toString(), ...entityValues];
+                }
+                const id = await Cfx.exports['oxmysql'].insert_async(`INSERT INTO \`${this.dbTableName}\` (${entityProperties.join(', ')}) VALUES (${Array(entityProperties.length).fill('?').join(', ')})`, entityValues);
+                const createdEntity = Object.assign(Object.assign({}, entity), { id: forceId || id });
+                this._entities.push(createdEntity);
+                this.syncWithClients();
+                return createdEntity;
+            }
+            catch (error) {
+                console.log(error);
+                return null;
+            }
+        })();
+    }
+    removeEntity(entity) {
+        return (async () => {
+            try {
+                const result = await Cfx.exports['oxmysql'].query_async(`DELETE FROM \`${this.dbTableName}\` WHERE id = ?`, [entity.id]);
+                this._entities = this._entities.filter((_entity) => _entity.id !== entity.id);
+                this.syncWithClients();
+                return !!result;
+            }
+            catch (error) {
+                console.log(error);
+                return false;
+            }
+        })();
+    }
+    saveDBEntityAsync(id) {
+        return (async () => {
+            try {
+                const entity = this.getEntityByDBId(id);
+                if (!entity)
+                    return false;
+                const updateKeys = this.getEntityProperties(entity);
+                const updateValues = this.getEntityPropertiesValues(entity, updateKeys);
+                const concatString = ' = ?, ';
+                const result = await Cfx.exports['oxmysql'].update_async(`UPDATE \`${this.dbTableName}\` SET ${updateKeys.join(concatString).concat(concatString).slice(0, -2)} WHERE id = ?`, [...updateValues, entity.id]);
+                if (result) {
+                    this.syncWithClients();
+                }
+                return result > 0;
+            }
+            catch (error) {
+                console.log(error);
+                return false;
+            }
+        })();
+    }
+    getEntityByDBId(id) {
+        return this._entities.find((_entity) => _entity.id === id);
+    }
+    async loadDBEntityFor(value, key = 'id', bindTo) {
+        const result = (await Cfx.exports['oxmysql'].query_async(`SELECT * FROM \`${this.dbTableName}\` WHERE ${key} = ?`, [value])).map((resultItem) => {
+            Object.keys(resultItem).forEach((property) => {
+                resultItem[property] = JSON.parse(isJSON(resultItem[property].toString()) ? resultItem[property] : `"${resultItem[property]}"`, function (_k, v) {
+                    return (typeof v === "object" || isNaN(v)) ? v : Number(v);
+                });
+            });
+            return resultItem;
+        });
+        if (result === null || result === void 0 ? void 0 : result.length) {
+            result.forEach((entity) => {
+                this._entities.push(entity);
+                if (bindTo) {
+                    this.bindEntityToPlayerByEntityId(entity.id, bindTo);
+                }
+            });
+            setTimeout(() => { this.syncWithClients(); }, 2000);
+            return ((result === null || result === void 0 ? void 0 : result.length) > 1 ? result : result[0]);
+        }
+        return null;
+    }
+    async loadDBEntities() {
+        const result = (await Cfx.exports['oxmysql'].query_async(`SELECT * FROM \`${this.dbTableName}\``, [])).map((resultItem) => {
+            Object.keys(resultItem).forEach((property) => {
+                resultItem[property] = JSON.parse(isJSON(resultItem[property].toString()) ? resultItem[property] : `"${resultItem[property]}"`, function (_k, v) {
+                    return (typeof v === "object" || isNaN(v)) ? v : Number(v);
+                });
+            });
+            return resultItem;
+        });
+        if (result === null || result === void 0 ? void 0 : result.length) {
+            this._entities = result;
+            setTimeout(() => { this.syncWithClients(); }, 2000);
+        }
+        return this._entities;
+    }
+    getEntityProperties(entity) {
+        const keys = [];
+        for (let key in entity) {
+            if (key !== 'id' && (!this._cachedProperties.length || this._cachedProperties.includes(key))) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
+    getEntityPropertiesValues(entity, properties) {
+        return properties.map((key) => {
+            if (Array.isArray(entity[key]) || typeof (entity[key]) === 'object') {
+                return JSON.stringify(entity[key]);
+            }
+            return entity[key].toString();
+        });
+    }
+    syncWithClients(client) {
+        // TODO: Probable performance issue cause. Entity updates should be sent to clients only for a specific property, so they don't need to wipe ALL data and rewrite it back.
+        Cfx.Server.TriggerClientEvent(`${Cfx.Server.GetCurrentResourceName()}:db-send-entities`, client || -1, this.entities);
+    }
+    bindEntityToPlayer(entity, playerId) {
+        if (this.entities.includes(entity)) {
+            this.bindEntityToPlayerByEntityId(entity.id, playerId);
+        }
+    }
+    bindEntityToPlayerByEntityId(id, playerId) {
+        const entityExists = this._entities.some((entity) => entity.id === id);
+        if (entityExists) {
+            if (this._playerToEntityBindings.has(playerId)) {
+                this._playerToEntityBindings.set(playerId, [...this._playerToEntityBindings.get(playerId), id]);
+            }
+            else {
+                this._playerToEntityBindings.set(playerId, [id]);
+            }
+        }
+    }
+    onBoundEntityDestroyed(_entity, _boundPlayer) { }
+    onPlayerAuthenticate(playerId, _player) {
+        if (this._entities.length) {
+            this.syncWithClients(playerId);
+        }
+    }
+    onPlayerDisconnect() {
+        if (this._playerToEntityBindings.has(Cfx.source)) {
+            const bindings = (this._playerToEntityBindings.has(Cfx.source)
+                ? this._playerToEntityBindings.get(Cfx.source)
+                : []);
+            bindings.forEach((entityId) => {
+                const entityBoundToPlayer = this._entities.find((entity) => entity.id === entityId);
+                if (entityBoundToPlayer) {
+                    this.onBoundEntityDestroyed(entityBoundToPlayer, Cfx.source);
+                    this._entities.splice(this._entities.indexOf(entityBoundToPlayer), 1);
+                }
+            });
+            this._playerToEntityBindings.delete(Cfx.source);
+        }
+    }
+    async computeTableProperties() {
+        const result = await Cfx.exports['oxmysql'].query_async(`DESCRIBE ${this.dbTableName}`, []);
+        if (result) {
+            result.forEach((sqlStructureObject) => {
+                this._cachedProperties.push(sqlStructureObject.Field);
+            });
+        }
+        else {
+            console.error(`[SQL ERROR:] computeTableProperties for ${Cfx.Server.GetCurrentResourceName()} did not work.`);
+        }
+    }
+};
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], ServerDBDependentController.prototype, "getEntities", null);
+__decorate([
+    EventListener(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Object]),
+    __metadata("design:returntype", void 0)
+], ServerDBDependentController.prototype, "onPlayerAuthenticate", null);
+__decorate([
+    EventListener(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ServerDBDependentController.prototype, "onPlayerDisconnect", null);
+ServerDBDependentController = __decorate([
+    Controller(),
+    __metadata("design:paramtypes", [String, Boolean])
+], ServerDBDependentController);
+export { ServerDBDependentController };

package/dist/esm/server/server.base.js

@@ -0,0 +1,28 @@
+// TODO: Remove
+export class ServerBase {
+    constructor() {
+        this.routingBucketCondition = (source, routingBucket) => true;
+        this.assignServerBaseListeners();
+    }
+    // TODO: Remove this. We have created a brand new cool decorator for this
+    RegisterAdminCommand(commandName, adminLevelRequired, handlerFunction, restricted) {
+        Cfx.Server.RegisterCommand(commandName, (source, args, _raw) => {
+            if (Number(Cfx.exports['authentication'].getPlayerInfo(source, 'adminLevel')) < adminLevelRequired) {
+                // TODO: Add error chat message OR some kind of visual notice here
+                return;
+            }
+            handlerFunction(source, args, _raw);
+        }, restricted);
+    }
+    assignServerBaseListeners() {
+        Cfx.Server.onNet(`${Cfx.Server.GetCurrentResourceName()}:set-client-routing-bucket`, (source, routingBucket) => {
+            if (this.routingBucketCondition(source, routingBucket)) {
+                Cfx.Server.SetEntityRoutingBucket(source, routingBucket);
+            }
+        });
+    }
+    setRoutingBucket(playerId, routingBucket) {
+        Cfx.Server.SetEntityRoutingBucket(Cfx.Server.GetPlayerPed(playerId.toString()), routingBucket);
+        Cfx.Server.TriggerClientEvent(`${Cfx.Server.GetCurrentResourceName()}:set-routing-bucket`, playerId, routingBucket);
+    }
+}

package/dist/esm/server/server.controller.js

@@ -0,0 +1,80 @@
+// TODO: Remove
+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);
+};
+import { Controller, EventListener } from '@armoury/fivem-framework-common';
+import { ServerEntities } from "./server.entities";
+let ServerController = class ServerController extends ServerEntities {
+    constructor() {
+        super(...arguments);
+        this._translationLanguage = 'en';
+        this._clientsidedResourceMap = new Map();
+    }
+    get translationLanguage() {
+        return this._translationLanguage;
+    }
+    get clientsidedResourceMap() {
+        return this._clientsidedResourceMap;
+    }
+    getPlayerClientsidedCacheKey(playerId, key) {
+        if (this._clientsidedResourceMap.has(playerId)) {
+            const metadataObject = this._clientsidedResourceMap.get(playerId);
+            if (metadataObject[key]) {
+                return metadataObject[key];
+            }
+        }
+        return null;
+    }
+    updatePlayerClientsidedCacheKey(playerId, key, value) {
+        const currentPlayerClientsidedResourceMapValue = this._clientsidedResourceMap.has(playerId)
+            ? this._clientsidedResourceMap.get(playerId) || {}
+            : {};
+        currentPlayerClientsidedResourceMapValue[key] = value;
+        this._clientsidedResourceMap.set(playerId, currentPlayerClientsidedResourceMapValue);
+        Cfx.Server.TriggerClientEvent('armoury-overlay:update-resource-metadata', playerId, Cfx.Server.GetCurrentResourceName(), key, value);
+    }
+    onPlayerClientsidedCacheLoaded(metadataObject) {
+        if (metadataObject[Cfx.Server.GetCurrentResourceName()]) {
+            this._clientsidedResourceMap.set(Cfx.source, metadataObject[Cfx.Server.GetCurrentResourceName()]);
+        }
+    }
+    onPlayerDisconnect() {
+        if (this._clientsidedResourceMap.has(Cfx.source)) {
+            this._clientsidedResourceMap.delete(Cfx.source);
+        }
+    }
+    translate(key, params) {
+        let content = this.translationFile[this._translationLanguage][key];
+        if (params) {
+            Object.keys(params).forEach((param) => {
+                content = content.replace(`{${param}}`, params[param]);
+            });
+        }
+        return content;
+    }
+    setTranslationLanguage(language) {
+        this._translationLanguage = language;
+    }
+};
+__decorate([
+    EventListener(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ServerController.prototype, "onPlayerClientsidedCacheLoaded", null);
+__decorate([
+    EventListener(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ServerController.prototype, "onPlayerDisconnect", null);
+ServerController = __decorate([
+    Controller()
+], ServerController);
+export { ServerController };

package/dist/esm/server/server.entities.js

@@ -0,0 +1,54 @@
+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);
+};
+// TODO: Remove
+import { Controller, EventListener } from '@armoury/fivem-framework-common';
+import { ServerBase } from './server.base';
+let ServerEntities = class ServerEntities extends ServerBase {
+    constructor() {
+        super(...arguments);
+        // Probable performance issue? Maybe calling the export so many times when changing the virtual world is too costly?
+        this._virtualWorldsWithPlayers = new Map();
+    }
+    /** This only counts virtual worlds related to the resource! If another resource changes the virtual world of the player, this resource won't know it! */
+    get virtualWorldsWithPlayers() {
+        return this._virtualWorldsWithPlayers;
+    }
+    onPlayerEnteredScope(data) {
+        Cfx.Server.TriggerClientEvent(`${Cfx.Server.GetCurrentResourceName()}:refresh-virtual-world`, data.for);
+    }
+    setPlayerVirtualWorld(playerId, virtualWorld) {
+        const currentPlayerVirtualWorld = this.getPlayerVirtualWorld(playerId);
+        if (!isNaN(currentPlayerVirtualWorld)) {
+            this._virtualWorldsWithPlayers.set(currentPlayerVirtualWorld, (this._virtualWorldsWithPlayers.has(currentPlayerVirtualWorld) ? this._virtualWorldsWithPlayers.get(currentPlayerVirtualWorld) : []).filter((_playerId) => _playerId !== playerId));
+        }
+        const newPlayersInVirtualWorld = [
+            ...(this._virtualWorldsWithPlayers.has(virtualWorld) ? this._virtualWorldsWithPlayers.get(virtualWorld) : []),
+            playerId
+        ];
+        this._virtualWorldsWithPlayers.set(virtualWorld, newPlayersInVirtualWorld);
+        Cfx.exports['authentication'].setPlayerInfo(playerId, 'virtualWorld', virtualWorld);
+    }
+    getPlayerVirtualWorld(playerId) {
+        return Math.max(0, Number(Cfx.exports['authentication'].getPlayerInfo(playerId, 'virtualWorld')));
+    }
+    removeClientsideVehicles() {
+        Cfx.Server.TriggerClientEvent(`${Cfx.Server.GetCurrentResourceName()}:ARM_remove-vehicles`, -1);
+    }
+};
+__decorate([
+    EventListener({ eventName: 'playerEnteredScope' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ServerEntities.prototype, "onPlayerEnteredScope", null);
+ServerEntities = __decorate([
+    Controller()
+], ServerEntities);
+export { ServerEntities };

package/dist/esm/server/services/index.js

@@ -0,0 +1,5 @@
+export * from './server-resource-database.service';
+export * from './server-enterable-database.service';
+export * from './server-virtual-worlds.service';
+export * from './server-translate.service';
+export * from './session';

package/dist/esm/server/services/server-enterable-database.service.js

@@ -0,0 +1,34 @@
+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;
+};
+import { Injectable } from "injection-js";
+import { ServerResourceDatabase } from "./server-resource-database.service";
+import { isPlayerInRangeOfPoint } from '@armoury/fivem-framework-common';
+let ServerEnterableDatabase = class ServerEnterableDatabase extends ServerResourceDatabase {
+    getClosestToPlayer(player) {
+        return this.getClosestExitToPlayer(player) || this.getClosestEntranceToPlayer(player);
+    }
+    getClosestEntranceToPlayer(source) {
+        // TODO: Replace here to actually get the closest, not the first one in the range
+        const playerPosition = Cfx.Server.GetEntityCoords(Cfx.Server.GetPlayerPed(source.toString()));
+        const entity = this.entities.find((_entity) => isPlayerInRangeOfPoint(playerPosition[0], playerPosition[1], playerPosition[2], _entity.entranceX, _entity.entranceY, _entity.entranceZ, 3.0));
+        return entity || null;
+    }
+    getClosestExitToPlayer(source) {
+        const virtualWorld = Math.max(0, Number(Cfx.exports['authentication'].getPlayerInfo(source, 'virtualWorld')));
+        const entity = this.getEntityByDBId(virtualWorld);
+        const playerPosition = Cfx.Server.GetEntityCoords(Cfx.Server.GetPlayerPed(source.toString()));
+        // TODO: Replace here to actually get the closest, not the first one in the range
+        if (entity && isPlayerInRangeOfPoint(playerPosition[0], playerPosition[1], playerPosition[2], entity.exitX, entity.exitY, entity.exitZ, 3.0)) {
+            return entity;
+        }
+        return null;
+    }
+};
+ServerEnterableDatabase = __decorate([
+    Injectable()
+], ServerEnterableDatabase);
+export { ServerEnterableDatabase };