@open-core/framework 0.1.0-alpha.1

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

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

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

@@ -0,0 +1,40 @@
+"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.FiveMEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_server_keys_1 = require("../metadata-server.keys");
+const logger_1 = require("../../../shared/logger");
+const resolve_method_1 = require("../../helpers/resolve-method");
+let FiveMEventProcessor = class FiveMEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_server_keys_1.METADATA_KEYS.FIVEM_EVENT;
+    }
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[FiveMEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName } = result;
+        on(metadata.event, (...args) => {
+            try {
+                handler(...args);
+            }
+            catch (error) {
+                logger_1.loggers.eventBus.error(`Handler error in FiveMEvent`, {
+                    event: metadata.event,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        logger_1.loggers.eventBus.debug(`Registered FiveM event: ${metadata.event} -> ${handlerName}`);
+    }
+};
+exports.FiveMEventProcessor = FiveMEventProcessor;
+exports.FiveMEventProcessor = FiveMEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], FiveMEventProcessor);

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

@@ -0,0 +1,11 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+import { PlayerService } from '../../services/player.service';
+import { NetEventOptions } from '../../decorators';
+import { SecurityHandlerContract } from '../../templates/security/security-handler.contract';
+export declare class NetEventProcessor implements DecoratorProcessor {
+    private playerService;
+    private securityHandler;
+    readonly metadataKey: string;
+    constructor(playerService: PlayerService, securityHandler: SecurityHandlerContract);
+    process(instance: any, methodName: string, metadata: NetEventOptions): void;
+}

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

@@ -0,0 +1,103 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const player_service_1 = require("../../services/player.service");
+const metadata_server_keys_1 = require("../metadata-server.keys");
+const security_handler_contract_1 = require("../../templates/security/security-handler.contract");
+const utils_1 = require("../../../utils");
+const logger_1 = require("../../../shared/logger");
+const zod_1 = __importDefault(require("zod"));
+const schema_generator_1 = require("../schema-generator");
+const resolve_method_1 = require("../../helpers/resolve-method");
+let NetEventProcessor = class NetEventProcessor {
+    constructor(playerService, securityHandler) {
+        this.playerService = playerService;
+        this.securityHandler = securityHandler;
+        this.metadataKey = metadata_server_keys_1.METADATA_KEYS.NET_EVENT;
+    }
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[NetEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName, proto } = result;
+        const isPublic = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.PUBLIC, proto, methodName) === true;
+        onNet(metadata.eventName, async (...args) => {
+            const sourceId = Number(source);
+            const player = this.playerService.getByClient(sourceId);
+            if (!player) {
+                logger_1.loggers.netEvent.warn(`Event ignored: Player session not found`, {
+                    event: metadata.eventName,
+                    clientId: sourceId,
+                });
+                return;
+            }
+            // ═══════════════════════════════════════════════════════════════
+            // SECURE BY DEFAULT: Require authentication unless @Public()
+            // ═══════════════════════════════════════════════════════════════
+            if (!isPublic && !player.accountID) {
+                logger_1.loggers.security.warn(`Unauthenticated request blocked`, {
+                    event: metadata.eventName,
+                    clientId: sourceId,
+                });
+                player.emit('core:auth:required', { event: metadata.eventName });
+                return;
+            }
+            let validatedArgs = args;
+            const schema = (0, schema_generator_1.generateSchemaFromTypes)(metadata.paramTypes);
+            if (schema) {
+                try {
+                    const parsed = schema.parse(args);
+                    validatedArgs = Array.isArray(parsed) ? parsed : [parsed];
+                }
+                catch (error) {
+                    if (error instanceof zod_1.default.ZodError) {
+                        const violation = new utils_1.SecurityError('LOG', `Invalid data received in ${metadata.eventName}`, { issues: error.message });
+                        this.securityHandler.handleViolation(player, violation);
+                        return;
+                    }
+                    if (error instanceof utils_1.SecurityError) {
+                        this.securityHandler.handleViolation(player, error);
+                        return;
+                    }
+                    logger_1.loggers.netEvent.error(`Validation error in event`, {
+                        event: metadata.eventName,
+                        playerId: player.clientID,
+                    }, error);
+                }
+            }
+            try {
+                await handler(player, ...validatedArgs);
+            }
+            catch (error) {
+                if (error instanceof utils_1.SecurityError) {
+                    this.securityHandler.handleViolation(player, error);
+                }
+                logger_1.loggers.netEvent.error(`Handler error in event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                    playerId: player.clientID,
+                }, error);
+            }
+        });
+        logger_1.loggers.netEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+exports.NetEventProcessor = NetEventProcessor;
+exports.NetEventProcessor = NetEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [player_service_1.PlayerService,
+        security_handler_contract_1.SecurityHandlerContract])
+], NetEventProcessor);

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

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

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

@@ -0,0 +1,36 @@
+"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.TickProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_server_keys_1 = require("../metadata-server.keys");
+const logger_1 = require("../../../shared/logger");
+let TickProcessor = class TickProcessor {
+    constructor() {
+        this.metadataKey = metadata_server_keys_1.METADATA_KEYS.TICK;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        setTick(async () => {
+            try {
+                await handler();
+            }
+            catch (error) {
+                logger_1.loggers.tick.error(`Tick handler error`, {
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        logger_1.loggers.tick.debug(`Registered: ${handlerName}`);
+    }
+};
+exports.TickProcessor = TickProcessor;
+exports.TickProcessor = TickProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], TickProcessor);

package/dist/server/system/processors.register.d.ts

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

package/dist/server/system/processors.register.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSystemServer = registerSystemServer;
+const container_1 = require("../container");
+const default_security_handler_1 = require("../services/default/default-security.handler");
+const security_handler_contract_1 = require("../templates/security/security-handler.contract");
+const command_processor_1 = require("./processors/command.processor");
+const coreEvent_processor_1 = require("./processors/coreEvent.processor");
+const export_processor_1 = require("./processors/export.processor");
+const fivemEvent_processor_1 = require("./processors/fivemEvent.processor");
+const netEvent_processor_1 = require("./processors/netEvent.processor");
+const tick_processor_1 = require("./processors/tick.processor");
+function registerSystemServer() {
+    container_1.di.register('DecoratorProcessor', { useClass: netEvent_processor_1.NetEventProcessor });
+    container_1.di.register('DecoratorProcessor', { useClass: tick_processor_1.TickProcessor });
+    container_1.di.register('DecoratorProcessor', { useClass: export_processor_1.ExportProcessor });
+    container_1.di.register('DecoratorProcessor', { useClass: coreEvent_processor_1.CoreEventProcessor });
+    container_1.di.register('DecoratorProcessor', { useClass: command_processor_1.CommandProcessor });
+    container_1.di.register('DecoratorProcessor', { useClass: fivemEvent_processor_1.FiveMEventProcessor });
+    if (!container_1.di.isRegistered(security_handler_contract_1.SecurityHandlerContract)) {
+        container_1.di.registerSingleton(security_handler_contract_1.SecurityHandlerContract, default_security_handler_1.DefaultSecurityHandler);
+    }
+}

package/dist/server/system/schema-generator.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare function generateSchemaFromTypes(paramTypes: any[]): z.ZodTuple | null;

package/dist/server/system/schema-generator.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaFromTypes = generateSchemaFromTypes;
+const zod_1 = __importDefault(require("zod"));
+const player_1 = require("../entities/player");
+function typeToZodSchema(type) {
+    switch (type) {
+        case String:
+            return zod_1.default.coerce.string();
+        case Number:
+            return zod_1.default.coerce.number();
+        case Boolean:
+            return zod_1.default.coerce.boolean();
+        case Array:
+            return zod_1.default.array(zod_1.default.any());
+        case Object:
+            return zod_1.default.any();
+        default:
+            return zod_1.default.any();
+    }
+}
+function generateSchemaFromTypes(paramTypes) {
+    var _a;
+    if (!paramTypes || paramTypes.length <= 1)
+        return null;
+    if (paramTypes[0] !== player_1.Player) {
+        throw new Error(`@OnNet: First parameter must be Player, got ${(_a = paramTypes[0]) === null || _a === void 0 ? void 0 : _a.name}`);
+    }
+    const argSchemas = paramTypes.slice(1).map(typeToZodSchema);
+    return zod_1.default.tuple(argSchemas);
+}

package/dist/server/templates/admin/admin.controller-template.d.ts

@@ -0,0 +1,12 @@
+import type { Player } from '../../entities';
+type CommandArgs = string[] | any;
+/**
+ * Template for admin controller implementations.
+ */
+export interface AdminControllerTemplate {
+    handleBanCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+    handleKickCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+    handleMuteCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+    handleUnmuteCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+}
+export {};

package/dist/server/templates/admin/admin.controller-template.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/templates/auth/auth-provider.contract.d.ts

@@ -0,0 +1,58 @@
+import type { LinkedID } from '../../services';
+import type { Server } from '../../..';
+export interface AuthCredentials {
+    /** Standard username/password auth */
+    username?: string;
+    password?: string;
+    /** License-based auto-auth */
+    license?: string;
+    /** Discord OAuth */
+    discordToken?: string;
+    /** Custom auth data */
+    [key: string]: unknown;
+}
+export interface AuthResult {
+    success: boolean;
+    accountID?: LinkedID;
+    error?: string;
+    /** Optional: newly created account flag */
+    isNewAccount?: boolean;
+}
+/**
+ * **Authentication**
+ *
+ * Defines the Authentication flow (login/register/logout).
+ * This is separate from Authorization (roles/permissions) handled by PrincipalProviderContract.
+ *
+ * @example
+ *
+ * class MyAuthProvider implements AuthProviderContract {
+ *   async authenticate(player, credentials) {
+ *     const user = await db.users.findByLicense(credentials.license)
+ *     if (!user) return { success: false, error: 'User not found' }
+ *     player.linkAccount(user.id)
+ *     return { success: true, accountID: user.id }
+ *   }
+ * }
+ *  */
+export declare abstract class AuthProviderContract {
+    /**
+     * Authenticates a player and links their account.
+     * Called during the login flow.
+     */
+    abstract authenticate(player: Server.Player, credentials: AuthCredentials): Promise<AuthResult>;
+    /**
+     * Registers a new account for the player.
+     * Can optionally auto-authenticate after registration.
+     */
+    abstract register(player: Server.Player, credentials: AuthCredentials): Promise<AuthResult>;
+    /**
+     * Validates an existing session/token.
+     * Useful for reconnections or persistent sessions.
+     */
+    abstract validateSession(player: Server.Player): Promise<AuthResult>;
+    /**
+     * Clears the player's authenticated session.
+     */
+    abstract logout(player: Server.Player): Promise<void>;
+}

package/dist/server/templates/auth/auth-provider.contract.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthProviderContract = void 0;
+/**
+ * **Authentication**
+ *
+ * Defines the Authentication flow (login/register/logout).
+ * This is separate from Authorization (roles/permissions) handled by PrincipalProviderContract.
+ *
+ * @example
+ *
+ * class MyAuthProvider implements AuthProviderContract {
+ *   async authenticate(player, credentials) {
+ *     const user = await db.users.findByLicense(credentials.license)
+ *     if (!user) return { success: false, error: 'User not found' }
+ *     player.linkAccount(user.id)
+ *     return { success: true, accountID: user.id }
+ *   }
+ * }
+ *  */
+class AuthProviderContract {
+}
+exports.AuthProviderContract = AuthProviderContract;

package/dist/server/templates/index.d.ts

@@ -0,0 +1,8 @@
+export * from './security/principal-provider.contract';
+export * from './repository';
+export * from './persistence';
+export * from './auth/auth-provider.contract';
+export type * from './security/permission.types';
+export type * from './admin/admin.controller-template';
+export type * from './repository/repository.types';
+export type * from './persistence/player-persistence.contract';

package/dist/server/templates/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Abstract templates and contracts
+__exportStar(require("./security/principal-provider.contract"), exports);
+__exportStar(require("./repository"), exports);
+__exportStar(require("./persistence"), exports);
+__exportStar(require("./auth/auth-provider.contract"), exports);

package/dist/server/templates/persistence/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Player Persistence Module
+ *
+ * Provides contracts and types for implementing player data persistence.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   PlayerPersistenceContract,
+ *   PersistenceConfig,
+ *   DEFAULT_PERSISTENCE_CONFIG
+ * } from '@open-core/framework/server'
+ *
+ * class MyPersistenceProvider extends PlayerPersistenceContract {
+ *   readonly config: PersistenceConfig = {
+ *     ...DEFAULT_PERSISTENCE_CONFIG,
+ *     autoSaveIntervalMs: 60000, // Override to 1 minute
+ *   }
+ *
+ *   async onSessionLoad(player) { ... }
+ *   async onSessionSave(player) { ... }
+ *   async onAutoSave(player) { ... }
+ * }
+ *
+ * // In your setup:
+ * Server.setPersistenceProvider(MyPersistenceProvider)
+ * ```
+ */
+export { PlayerPersistenceContract, DEFAULT_PERSISTENCE_CONFIG, } from './player-persistence.contract';
+export type { PersistenceConfig } from './player-persistence.contract';

package/dist/server/templates/persistence/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Player Persistence Module
+ *
+ * Provides contracts and types for implementing player data persistence.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   PlayerPersistenceContract,
+ *   PersistenceConfig,
+ *   DEFAULT_PERSISTENCE_CONFIG
+ * } from '@open-core/framework/server'
+ *
+ * class MyPersistenceProvider extends PlayerPersistenceContract {
+ *   readonly config: PersistenceConfig = {
+ *     ...DEFAULT_PERSISTENCE_CONFIG,
+ *     autoSaveIntervalMs: 60000, // Override to 1 minute
+ *   }
+ *
+ *   async onSessionLoad(player) { ... }
+ *   async onSessionSave(player) { ... }
+ *   async onAutoSave(player) { ... }
+ * }
+ *
+ * // In your setup:
+ * Server.setPersistenceProvider(MyPersistenceProvider)
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PERSISTENCE_CONFIG = exports.PlayerPersistenceContract = void 0;
+var player_persistence_contract_1 = require("./player-persistence.contract");
+Object.defineProperty(exports, "PlayerPersistenceContract", { enumerable: true, get: function () { return player_persistence_contract_1.PlayerPersistenceContract; } });
+Object.defineProperty(exports, "DEFAULT_PERSISTENCE_CONFIG", { enumerable: true, get: function () { return player_persistence_contract_1.DEFAULT_PERSISTENCE_CONFIG; } });

package/dist/server/templates/persistence/player-persistence.contract.d.ts

@@ -0,0 +1,86 @@
+import type { Player } from '../../entities/player';
+/**
+ * Configuration for player data persistence behavior.
+ */
+export interface PersistenceConfig {
+    /**
+     * Whether automatic saving is enabled.
+     * When true, player data will be saved periodically.
+     */
+    autoSaveEnabled: boolean;
+    /**
+     * Interval in milliseconds between auto-saves.
+     * @default 300000 (5 minutes)
+     */
+    autoSaveIntervalMs: number;
+}
+/**
+ * Default persistence configuration values.
+ */
+export declare const DEFAULT_PERSISTENCE_CONFIG: PersistenceConfig;
+/**
+ * Player Persistence Contract
+ *
+ * Abstract base class for implementing player data persistence.
+ * Implement this contract to define how player data is loaded, saved,
+ * and automatically persisted during their session.
+ *
+ * @example
+ * ```typescript
+ * import { PlayerPersistenceContract, PersistenceConfig } from '@open-core/framework/server'
+ *
+ * class MyPersistenceProvider extends PlayerPersistenceContract {
+ *   readonly config: PersistenceConfig = {
+ *     autoSaveEnabled: true,
+ *     autoSaveIntervalMs: 300000, // 5 minutes
+ *   }
+ *
+ *   async onSessionLoad(player: Player): Promise<void> {
+ *     const data = await this.db.single('SELECT * FROM players WHERE license = ?', [player.license])
+ *     if (data) {
+ *       player.setMeta('money', data.money)
+ *       player.setMeta('job', data.job)
+ *     }
+ *   }
+ *
+ *   async onSessionSave(player: Player): Promise<void> {
+ *     await this.db.execute(
+ *       'UPDATE players SET money = ?, job = ? WHERE license = ?',
+ *       [player.getMeta('money'), player.getMeta('job'), player.license]
+ *     )
+ *   }
+ *
+ *   async onAutoSave(player: Player): Promise<void> {
+ *     // Can delegate to onSessionSave or implement lighter save logic
+ *     await this.onSessionSave(player)
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class PlayerPersistenceContract {
+    /**
+     * Persistence configuration for this provider.
+     */
+    abstract readonly config: PersistenceConfig;
+    /**
+     * Called when a player session is created (after playerJoining).
+     * Load saved data from persistent storage and attach to the player.
+     *
+     * @param player - The player whose data should be loaded
+     */
+    abstract onSessionLoad(player: Player): Promise<void>;
+    /**
+     * Called when a player disconnects (before session destroy).
+     * Save player data to persistent storage.
+     *
+     * @param player - The player whose data should be saved
+     */
+    abstract onSessionSave(player: Player): Promise<void>;
+    /**
+     * Called periodically if autoSave is enabled.
+     * Can implement lighter save logic or delegate to onSessionSave.
+     *
+     * @param player - The player whose data should be auto-saved
+     */
+    abstract onAutoSave(player: Player): Promise<void>;
+}

package/dist/server/templates/persistence/player-persistence.contract.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerPersistenceContract = exports.DEFAULT_PERSISTENCE_CONFIG = void 0;
+/**
+ * Default persistence configuration values.
+ */
+exports.DEFAULT_PERSISTENCE_CONFIG = {
+    autoSaveEnabled: true,
+    autoSaveIntervalMs: 300000, // 5 minutes
+};
+/**
+ * Player Persistence Contract
+ *
+ * Abstract base class for implementing player data persistence.
+ * Implement this contract to define how player data is loaded, saved,
+ * and automatically persisted during their session.
+ *
+ * @example
+ * ```typescript
+ * import { PlayerPersistenceContract, PersistenceConfig } from '@open-core/framework/server'
+ *
+ * class MyPersistenceProvider extends PlayerPersistenceContract {
+ *   readonly config: PersistenceConfig = {
+ *     autoSaveEnabled: true,
+ *     autoSaveIntervalMs: 300000, // 5 minutes
+ *   }
+ *
+ *   async onSessionLoad(player: Player): Promise<void> {
+ *     const data = await this.db.single('SELECT * FROM players WHERE license = ?', [player.license])
+ *     if (data) {
+ *       player.setMeta('money', data.money)
+ *       player.setMeta('job', data.job)
+ *     }
+ *   }
+ *
+ *   async onSessionSave(player: Player): Promise<void> {
+ *     await this.db.execute(
+ *       'UPDATE players SET money = ?, job = ? WHERE license = ?',
+ *       [player.getMeta('money'), player.getMeta('job'), player.license]
+ *     )
+ *   }
+ *
+ *   async onAutoSave(player: Player): Promise<void> {
+ *     // Can delegate to onSessionSave or implement lighter save logic
+ *     await this.onSessionSave(player)
+ *   }
+ * }
+ * ```
+ */
+class PlayerPersistenceContract {
+}
+exports.PlayerPersistenceContract = PlayerPersistenceContract;