@open-core/framework 1.0.1-beta.1

package/dist/server/services/persistence.service.d.ts

@@ -0,0 +1,59 @@
+import type { Player } from '../entities/player';
+/**
+ * Internal service that orchestrates player data persistence.
+ *
+ * This service manages the lifecycle of persistence hooks and auto-save intervals.
+ * It is used internally by the framework and should not be instantiated directly.
+ */
+export declare class PlayerPersistenceService {
+    private provider;
+    private autoSaveIntervals;
+    private initialized;
+    /**
+     * Initializes the persistence service by resolving the provider from DI.
+     * Called during bootstrap if a provider is registered.
+     */
+    initialize(): void;
+    /**
+     * Whether persistence is enabled (provider is configured).
+     */
+    get isEnabled(): boolean;
+    /**
+     * Handles player session load - called when a player joins.
+     *
+     * @param player - The player who just joined
+     */
+    handleSessionLoad(player: Player): Promise<void>;
+    /**
+     * Handles player session save - called when a player disconnects.
+     *
+     * @param player - The player who is disconnecting
+     */
+    handleSessionSave(player: Player): Promise<void>;
+    /**
+     * Manually triggers a save for a specific player.
+     *
+     * @param player - The player whose data should be saved
+     */
+    savePlayer(player: Player): Promise<void>;
+    /**
+     * Saves all connected players' data.
+     * Useful for server shutdown or periodic global saves.
+     *
+     * @param players - Array of all connected players
+     */
+    saveAllPlayers(players: Player[]): Promise<void>;
+    /**
+     * Starts the auto-save interval for a player.
+     */
+    private startAutoSave;
+    /**
+     * Stops the auto-save interval for a player.
+     */
+    private stopAutoSave;
+    /**
+     * Stops all auto-save intervals.
+     * Called during server shutdown.
+     */
+    stopAllAutoSaves(): void;
+}

package/dist/server/services/persistence.service.js

@@ -0,0 +1,166 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerPersistenceService = void 0;
+const tsyringe_1 = require("tsyringe");
+const container_1 = require("../container");
+const persistence_1 = require("../templates/persistence");
+const logger_1 = require("../../shared/logger");
+/**
+ * Internal service that orchestrates player data persistence.
+ *
+ * This service manages the lifecycle of persistence hooks and auto-save intervals.
+ * It is used internally by the framework and should not be instantiated directly.
+ */
+let PlayerPersistenceService = class PlayerPersistenceService {
+    constructor() {
+        this.provider = null;
+        this.autoSaveIntervals = new Map();
+        this.initialized = false;
+    }
+    /**
+     * Initializes the persistence service by resolving the provider from DI.
+     * Called during bootstrap if a provider is registered.
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        try {
+            if (container_1.di.isRegistered(persistence_1.PlayerPersistenceContract)) {
+                const provider = container_1.di.resolve(persistence_1.PlayerPersistenceContract);
+                this.provider = provider;
+                logger_1.loggers.bootstrap.info('Player Persistence Provider initialized', {
+                    autoSaveEnabled: provider.config.autoSaveEnabled,
+                    autoSaveIntervalMs: provider.config.autoSaveIntervalMs,
+                });
+            }
+        }
+        catch (_a) {
+            // Provider not registered, persistence is disabled
+            this.provider = null;
+        }
+        this.initialized = true;
+    }
+    /**
+     * Whether persistence is enabled (provider is configured).
+     */
+    get isEnabled() {
+        return this.provider !== null;
+    }
+    /**
+     * Handles player session load - called when a player joins.
+     *
+     * @param player - The player who just joined
+     */
+    async handleSessionLoad(player) {
+        if (!this.provider)
+            return;
+        try {
+            await this.provider.onSessionLoad(player);
+            logger_1.loggers.session.debug('Player data loaded', { clientId: player.clientID });
+            // Start auto-save interval if enabled
+            if (this.provider.config.autoSaveEnabled) {
+                this.startAutoSave(player);
+            }
+        }
+        catch (error) {
+            logger_1.loggers.session.error('Failed to load player data', { clientId: player.clientID }, error);
+        }
+    }
+    /**
+     * Handles player session save - called when a player disconnects.
+     *
+     * @param player - The player who is disconnecting
+     */
+    async handleSessionSave(player) {
+        if (!this.provider)
+            return;
+        // Stop auto-save interval first
+        this.stopAutoSave(player.clientID);
+        try {
+            await this.provider.onSessionSave(player);
+            logger_1.loggers.session.debug('Player data saved', { clientId: player.clientID });
+        }
+        catch (error) {
+            logger_1.loggers.session.error('Failed to save player data', { clientId: player.clientID }, error);
+        }
+    }
+    /**
+     * Manually triggers a save for a specific player.
+     *
+     * @param player - The player whose data should be saved
+     */
+    async savePlayer(player) {
+        if (!this.provider)
+            return;
+        try {
+            await this.provider.onSessionSave(player);
+            logger_1.loggers.session.debug('Player data manually saved', { clientId: player.clientID });
+        }
+        catch (error) {
+            logger_1.loggers.session.error('Failed to manually save player data', { clientId: player.clientID }, error);
+        }
+    }
+    /**
+     * Saves all connected players' data.
+     * Useful for server shutdown or periodic global saves.
+     *
+     * @param players - Array of all connected players
+     */
+    async saveAllPlayers(players) {
+        if (!this.provider)
+            return;
+        const savePromises = players.map((player) => this.provider.onSessionSave(player).catch((error) => {
+            logger_1.loggers.session.error('Failed to save player data during bulk save', { clientId: player.clientID }, error);
+        }));
+        await Promise.all(savePromises);
+        logger_1.loggers.session.info('Bulk player save completed', { playerCount: players.length });
+    }
+    /**
+     * Starts the auto-save interval for a player.
+     */
+    startAutoSave(player) {
+        if (!this.provider)
+            return;
+        const intervalMs = this.provider.config.autoSaveIntervalMs;
+        const interval = setInterval(async () => {
+            try {
+                await this.provider.onAutoSave(player);
+                logger_1.loggers.session.debug('Player auto-save completed', { clientId: player.clientID });
+            }
+            catch (error) {
+                logger_1.loggers.session.error('Auto-save failed', { clientId: player.clientID }, error);
+            }
+        }, intervalMs);
+        this.autoSaveIntervals.set(player.clientID, interval);
+    }
+    /**
+     * Stops the auto-save interval for a player.
+     */
+    stopAutoSave(clientId) {
+        const interval = this.autoSaveIntervals.get(clientId);
+        if (interval) {
+            clearInterval(interval);
+            this.autoSaveIntervals.delete(clientId);
+        }
+    }
+    /**
+     * Stops all auto-save intervals.
+     * Called during server shutdown.
+     */
+    stopAllAutoSaves() {
+        for (const interval of this.autoSaveIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.autoSaveIntervals.clear();
+    }
+};
+exports.PlayerPersistenceService = PlayerPersistenceService;
+exports.PlayerPersistenceService = PlayerPersistenceService = __decorate([
+    (0, tsyringe_1.injectable)()
+], PlayerPersistenceService);

package/dist/server/services/player.service.d.ts

@@ -0,0 +1,96 @@
+import type { UUIDTypes } from 'uuid';
+import { Player } from '../entities/player';
+/**
+ * Type representing a linked account identifier. This come from your persistence layer
+ * and is used to associate a Player session with their stored data.
+ */
+export type LinkedID = string | UUIDTypes;
+export interface PlayerSession {
+    clientID: number;
+    accountID?: LinkedID;
+    identifiers?: {
+        license?: string;
+        steam?: string;
+        discord?: string;
+    };
+    meta: Record<string, unknown>;
+}
+/**
+ * Service responsible for managing the lifecycle of player sessions.
+ * It acts as the central registry for all connected players, mapping FiveM client IDs
+ * to Core `Player` entities.
+ */
+export declare class PlayerService {
+    /**
+     * Internal map storing active player sessions indexed by their FiveM client ID (source).
+     */
+    private playersByClient;
+    /**
+     * Initializes a new player session for a connecting client.
+     *
+     * This method is typically called during the `playerJoining` event or
+     * immediately after a successful handshake/login flow.
+     *
+     * @param clientID - The FiveM server ID (source) of the player.
+     * @param identifiers - Optional object containing platform identifiers (license, steam, etc.).
+     * @returns The newly created `Player` instance.
+     */
+    bind(clientID: number, identifiers?: PlayerSession['identifiers']): Player;
+    /**
+     * Associates an authenticated Account ID (database ID) with an active player session.
+     *
+     * Call this method once the player has successfully authenticated (e.g., after character selection
+     * or login) to link their session to their persistent data.
+     *
+     * @param clientID - The FiveM server ID of the player.
+     * @param accountID - The unique identifier from your database/persistence layer.
+     */
+    linkAccount(clientID: number, accountID: LinkedID): void;
+    /**
+     * Terminates a player session and removes them from the registry.
+     *
+     * This should be called when the `playerDropped` event is triggered to ensure
+     * memory is freed and the session is closed.
+     *
+     * @param clientID - The FiveM server ID of the player disconnecting.
+     */
+    unbindByClient(clientID: number): void;
+    /**
+     * Retrieves the `Player` entity associated with a specific FiveM client ID.
+     *
+     * @param clientID - The FiveM server ID to look up.
+     * @returns The `Player` instance if found, or `null` if the session does not exist.
+     */
+    getByClient(clientID: number): Player | null;
+    /**
+     * Helper to retrieve the authenticated Account ID for a given client.
+     *
+     * @param clientID - The FiveM server ID to look up.
+     * @returns The bound Account ID (string/UUID) if the player is logged in, or `null` otherwise.
+     */
+    getPlayerId(clientID: number): string | null;
+    /**
+     * Stores arbitrary metadata in the player's session.
+     * Useful for storing transient state like 'isDead', 'job', 'dimension', etc.
+     *
+     * @param clientID - The FiveM server ID of the player.
+     * @param key - The unique key for the metadata entry.
+     * @param value - The value to store.
+     */
+    setMeta(clientID: number, key: string, value: unknown): void;
+    /**
+     * Retrieves metadata previously stored in the player's session.
+     *
+     * @template T - The expected type of the returned value.
+     * @param clientID - The FiveM server ID of the player.
+     * @param key - The metadata key to retrieve.
+     * @returns The value cast to type `T`, or `undefined` if the key or player doesn't exist.
+     */
+    getMeta<T = unknown>(clientID: number, key: string): T | undefined;
+    /**
+     * Returns a list of all currently active `Player` entities.
+     *
+     * @returns An array containing all connected players managed by this service.
+     */
+    getAll(): Player[];
+}

package/dist/server/services/player.service.js

@@ -0,0 +1,132 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerService = void 0;
+const tsyringe_1 = require("tsyringe");
+const player_1 = require("../entities/player");
+/**
+ * Service responsible for managing the lifecycle of player sessions.
+ * It acts as the central registry for all connected players, mapping FiveM client IDs
+ * to Core `Player` entities.
+ */
+let PlayerService = class PlayerService {
+    constructor() {
+        /**
+         * Internal map storing active player sessions indexed by their FiveM client ID (source).
+         */
+        this.playersByClient = new Map();
+    }
+    /**
+     * Initializes a new player session for a connecting client.
+     *
+     * This method is typically called during the `playerJoining` event or
+     * immediately after a successful handshake/login flow.
+     *
+     * @param clientID - The FiveM server ID (source) of the player.
+     * @param identifiers - Optional object containing platform identifiers (license, steam, etc.).
+     * @returns The newly created `Player` instance.
+     */
+    bind(clientID, identifiers) {
+        const session = {
+            clientID,
+            identifiers,
+            meta: {},
+        };
+        const player = new player_1.Player(session);
+        this.playersByClient.set(clientID, player);
+        return player;
+    }
+    /**
+     * Associates an authenticated Account ID (database ID) with an active player session.
+     *
+     * Call this method once the player has successfully authenticated (e.g., after character selection
+     * or login) to link their session to their persistent data.
+     *
+     * @param clientID - The FiveM server ID of the player.
+     * @param accountID - The unique identifier from your database/persistence layer.
+     */
+    linkAccount(clientID, accountID) {
+        const player = this.playersByClient.get(clientID);
+        if (!player)
+            return;
+        player.linkAccount(accountID);
+    }
+    /**
+     * Terminates a player session and removes them from the registry.
+     *
+     * This should be called when the `playerDropped` event is triggered to ensure
+     * memory is freed and the session is closed.
+     *
+     * @param clientID - The FiveM server ID of the player disconnecting.
+     */
+    unbindByClient(clientID) {
+        const player = this.playersByClient.get(clientID);
+        if (!player)
+            return;
+        this.playersByClient.delete(clientID);
+    }
+    /**
+     * Retrieves the `Player` entity associated with a specific FiveM client ID.
+     *
+     * @param clientID - The FiveM server ID to look up.
+     * @returns The `Player` instance if found, or `null` if the session does not exist.
+     */
+    getByClient(clientID) {
+        var _a;
+        return (_a = this.playersByClient.get(clientID)) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Helper to retrieve the authenticated Account ID for a given client.
+     *
+     * @param clientID - The FiveM server ID to look up.
+     * @returns The bound Account ID (string/UUID) if the player is logged in, or `null` otherwise.
+     */
+    getPlayerId(clientID) {
+        var _a;
+        const player = this.playersByClient.get(clientID);
+        return (_a = player === null || player === void 0 ? void 0 : player.accountID) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Stores arbitrary metadata in the player's session.
+     * Useful for storing transient state like 'isDead', 'job', 'dimension', etc.
+     *
+     * @param clientID - The FiveM server ID of the player.
+     * @param key - The unique key for the metadata entry.
+     * @param value - The value to store.
+     */
+    setMeta(clientID, key, value) {
+        const player = this.playersByClient.get(clientID);
+        if (!player)
+            return;
+        player.setMeta(key, value);
+    }
+    /**
+     * Retrieves metadata previously stored in the player's session.
+     *
+     * @template T - The expected type of the returned value.
+     * @param clientID - The FiveM server ID of the player.
+     * @param key - The metadata key to retrieve.
+     * @returns The value cast to type `T`, or `undefined` if the key or player doesn't exist.
+     */
+    getMeta(clientID, key) {
+        const player = this.playersByClient.get(clientID);
+        return player === null || player === void 0 ? void 0 : player.getMeta(key);
+    }
+    /**
+     * Returns a list of all currently active `Player` entities.
+     *
+     * @returns An array containing all connected players managed by this service.
+     */
+    getAll() {
+        return Array.from(this.playersByClient.values());
+    }
+};
+exports.PlayerService = PlayerService;
+exports.PlayerService = PlayerService = __decorate([
+    (0, tsyringe_1.injectable)()
+], PlayerService);

package/dist/server/services/rate-limiter.service.d.ts

@@ -0,0 +1,5 @@
+export declare class RateLimiterService {
+    private hits;
+    checkLimit(key: string, limit: number, windowMs: number): boolean;
+    private cleanup;
+}

package/dist/server/services/rate-limiter.service.js

@@ -0,0 +1,39 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiterService = void 0;
+const tsyringe_1 = require("tsyringe");
+let RateLimiterService = class RateLimiterService {
+    constructor() {
+        this.hits = new Map();
+    }
+    checkLimit(key, limit, windowMs) {
+        const now = Date.now();
+        const timestamps = this.hits.get(key) || [];
+        const validTimestamps = timestamps.filter((t) => now - t < windowMs);
+        if (validTimestamps.length >= limit) {
+            return false;
+        }
+        validTimestamps.push(now);
+        this.hits.set(key, validTimestamps);
+        if (this.hits.size > 5000)
+            this.cleanup();
+        return true;
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, times] of this.hits.entries()) {
+            if (times.every((t) => now - t > 60000))
+                this.hits.delete(key);
+        }
+    }
+};
+exports.RateLimiterService = RateLimiterService;
+exports.RateLimiterService = RateLimiterService = __decorate([
+    (0, tsyringe_1.injectable)()
+], RateLimiterService);

package/dist/server/services/registers.d.ts

@@ -0,0 +1 @@
+export declare function registerServicesServer(): void;

package/dist/server/services/registers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServicesServer = registerServicesServer;
+const container_1 = require("../container");
+const database_1 = require("../database");
+const chat_service_1 = require("./chat.service");
+const command_service_1 = require("./command.service");
+const http_service_1 = require("./http/http.service");
+const player_service_1 = require("./player.service");
+const persistence_service_1 = require("./persistence.service");
+function registerServicesServer() {
+    container_1.di.registerSingleton(player_service_1.PlayerService, player_service_1.PlayerService);
+    container_1.di.registerSingleton(command_service_1.CommandService, command_service_1.CommandService);
+    container_1.di.registerSingleton(http_service_1.HttpService, http_service_1.HttpService);
+    container_1.di.registerSingleton(chat_service_1.ChatService, chat_service_1.ChatService);
+    container_1.di.registerSingleton(database_1.DatabaseService, database_1.DatabaseService);
+    container_1.di.registerSingleton(persistence_service_1.PlayerPersistenceService, persistence_service_1.PlayerPersistenceService);
+}

package/dist/server/setup.d.ts

@@ -0,0 +1,9 @@
+import type { ClassConstructor } from '../system/class-constructor';
+import { PrincipalProviderContract } from './templates';
+import { SecurityHandlerContract } from './templates/security/security-handler.contract';
+import { PlayerPersistenceContract } from './templates/persistence';
+import { AuthProviderContract } from './templates/auth/auth-provider.contract';
+export declare function setPrincipalProvider(provider: ClassConstructor<PrincipalProviderContract>): void;
+export declare function setAuthProvider(provider: ClassConstructor<AuthProviderContract>): void;
+export declare function setSecurityHandler(handler: ClassConstructor<SecurityHandlerContract>): void;
+export declare function setPersistenceProvider(provider: ClassConstructor<PlayerPersistenceContract>): void;

package/dist/server/setup.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPrincipalProvider = setPrincipalProvider;
+exports.setAuthProvider = setAuthProvider;
+exports.setSecurityHandler = setSecurityHandler;
+exports.setPersistenceProvider = setPersistenceProvider;
+const container_1 = require("./container");
+const templates_1 = require("./templates");
+const security_handler_contract_1 = require("./templates/security/security-handler.contract");
+const persistence_1 = require("./templates/persistence");
+const logger_1 = require("../shared/logger");
+const auth_provider_contract_1 = require("./templates/auth/auth-provider.contract");
+function setPrincipalProvider(provider) {
+    container_1.di.registerSingleton(templates_1.PrincipalProviderContract, provider);
+    logger_1.loggers.bootstrap.info(`Principal Provider configured: ${provider.name}`);
+}
+function setAuthProvider(provider) {
+    container_1.di.registerSingleton(auth_provider_contract_1.AuthProviderContract, provider);
+    logger_1.loggers.bootstrap.info(`Auth Provider configured: ${provider.name}`);
+}
+function setSecurityHandler(handler) {
+    container_1.di.registerSingleton(security_handler_contract_1.SecurityHandlerContract, handler);
+    logger_1.loggers.bootstrap.info(`Security Handler configured: ${handler.name}`);
+}
+function setPersistenceProvider(provider) {
+    container_1.di.registerSingleton(persistence_1.PlayerPersistenceContract, provider);
+    logger_1.loggers.bootstrap.info(`Persistence Provider configured: ${provider.name}`);
+}

package/dist/server/system/metadata-server.keys.d.ts

@@ -0,0 +1,9 @@
+export declare const METADATA_KEYS: {
+    CONTROLLER: string;
+    COMMAND: string;
+    NET_EVENT: string;
+    TICK: string;
+    CORE_EVENT: string;
+    EXPORT: string;
+    PUBLIC: string;
+};

package/dist/server/system/metadata-server.keys.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_KEYS = void 0;
+exports.METADATA_KEYS = {
+    CONTROLLER: 'core:meta:controller',
+    COMMAND: 'core:meta:command',
+    NET_EVENT: 'core:meta:net_event',
+    TICK: 'core:meta:tick',
+    CORE_EVENT: 'core:meta:core_event',
+    EXPORT: 'core:meta:export',
+    PUBLIC: 'core:meta:public',
+};

package/dist/server/system/processors/command.processor.d.ts

@@ -0,0 +1,9 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+import { CommandService } from '../../services';
+import { CommandConfig } from '../../decorators';
+export declare class CommandProcessor implements DecoratorProcessor {
+    private commandService;
+    readonly metadataKey: string;
+    constructor(commandService: CommandService);
+    process(target: any, methodName: string, metadata: CommandConfig): void;
+}

package/dist/server/system/processors/command.processor.js

@@ -0,0 +1,31 @@
+"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.CommandProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_server_keys_1 = require("../metadata-server.keys");
+const services_1 = require("../../services");
+let CommandProcessor = class CommandProcessor {
+    constructor(commandService) {
+        this.commandService = commandService;
+        this.metadataKey = metadata_server_keys_1.METADATA_KEYS.COMMAND;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const fullMeta = Object.assign(Object.assign({}, metadata), { methodName, target: target.constructor });
+        this.commandService.register(fullMeta, handler);
+    }
+};
+exports.CommandProcessor = CommandProcessor;
+exports.CommandProcessor = CommandProcessor = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [services_1.CommandService])
+], CommandProcessor);

package/dist/server/system/processors/coreEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class CoreEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        event: string;
+    }): void;
+}