@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.1

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

@@ -1,52 +0,0 @@
-"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;

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

@@ -1,57 +0,0 @@
-/**
- * Repository Pattern Module
- *
- * Provides an abstract Repository base class for implementing
- * the Repository Pattern with type-safe CRUD operations.
- *
- * @example
- * ```typescript
- * import { Repository, FindOptions } from '@open-core/framework/server'
- * import type { DatabaseContract } from '@open-core/framework/server'
- *
- * interface User {
- *   id: number
- *   name: string
- *   email: string
- *   active: boolean
- * }
- *
- * class UserRepository extends Repository<User> {
- *   protected tableName = 'users'
- *
- *   constructor(db: DatabaseContract) {
- *     super(db)
- *   }
- *
- *   protected toEntity(row: any): User {
- *     return {
- *       id: row.id,
- *       name: row.name,
- *       email: row.email,
- *       active: Boolean(row.active)
- *     }
- *   }
- *
- *   protected toRow(entity: User): Record<string, any> {
- *     return {
- *       id: entity.id,
- *       name: entity.name,
- *       email: entity.email,
- *       active: entity.active ? 1 : 0
- *     }
- *   }
- *
- *   // Custom methods
- *   async findByEmail(email: string): Promise<User | null> {
- *     return this.findOne({ email })
- *   }
- *
- *   async findActive(options?: FindOptions<User>): Promise<User[]> {
- *     const { data } = await this.findMany({ active: true }, options)
- *     return data
- *   }
- * }
- * ```
- */
-export type { OrderDirection, FindOptions, FindManyResult, WhereCondition, } from './repository.types';
-export { Repository } from './repository.contract';

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

@@ -1,61 +0,0 @@
-"use strict";
-/**
- * Repository Pattern Module
- *
- * Provides an abstract Repository base class for implementing
- * the Repository Pattern with type-safe CRUD operations.
- *
- * @example
- * ```typescript
- * import { Repository, FindOptions } from '@open-core/framework/server'
- * import type { DatabaseContract } from '@open-core/framework/server'
- *
- * interface User {
- *   id: number
- *   name: string
- *   email: string
- *   active: boolean
- * }
- *
- * class UserRepository extends Repository<User> {
- *   protected tableName = 'users'
- *
- *   constructor(db: DatabaseContract) {
- *     super(db)
- *   }
- *
- *   protected toEntity(row: any): User {
- *     return {
- *       id: row.id,
- *       name: row.name,
- *       email: row.email,
- *       active: Boolean(row.active)
- *     }
- *   }
- *
- *   protected toRow(entity: User): Record<string, any> {
- *     return {
- *       id: entity.id,
- *       name: entity.name,
- *       email: entity.email,
- *       active: entity.active ? 1 : 0
- *     }
- *   }
- *
- *   // Custom methods
- *   async findByEmail(email: string): Promise<User | null> {
- *     return this.findOne({ email })
- *   }
- *
- *   async findActive(options?: FindOptions<User>): Promise<User[]> {
- *     const { data } = await this.findMany({ active: true }, options)
- *     return data
- *   }
- * }
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
-// Contract
-var repository_contract_1 = require("./repository.contract");
-Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return repository_contract_1.Repository; } });

package/dist/server/templates/repository/repository.contract.d.ts

@@ -1,224 +0,0 @@
-/**
- * Repository Contract
- *
- * Abstract base class for implementing the Repository Pattern.
- * Provides common CRUD operations with support for pagination, ordering, and field selection.
- *
- * @example
- * ```typescript
- * interface User {
- *   id: number
- *   name: string
- *   email: string
- *   createdAt: Date
- * }
- *
- * class UserRepository extends Repository<User> {
- *   protected tableName = 'users'
- *
- *   constructor(db: DatabaseContract) {
- *     super(db)
- *   }
- *
- *   protected toEntity(row: any): User {
- *     return {
- *       id: row.id,
- *       name: row.name,
- *       email: row.email,
- *       createdAt: new Date(row.created_at)
- *     }
- *   }
- *
- *   protected toRow(entity: User): Record<string, any> {
- *     return {
- *       id: entity.id,
- *       name: entity.name,
- *       email: entity.email,
- *       created_at: entity.createdAt.toISOString()
- *     }
- *   }
- * }
- *
- * // Usage
- * const userRepo = new UserRepository(db)
- * const user = await userRepo.findById(1)
- * const users = await userRepo.findMany({ active: true }, { limit: 10, orderBy: { createdAt: 'DESC' } })
- * ```
- */
-import type { DatabaseContract } from '../../database/database.contract';
-import type { FindOptions, FindManyResult, WhereCondition, OrderDirection } from './repository.types';
-/**
- * Abstract Repository base class
- *
- * Extend this class to create type-safe repositories for your entities.
- *
- * @typeParam TEntity - The entity type this repository manages
- * @typeParam TId - The type of the primary key (defaults to number)
- */
-export declare abstract class Repository<TEntity, TId = number> {
-    protected readonly db: DatabaseContract;
-    /**
-     * The database table name for this entity
-     */
-    protected abstract tableName: string;
-    /**
-     * The primary key column name (defaults to 'id')
-     */
-    protected primaryKey: string;
-    /**
-     * Creates a new repository instance
-     *
-     * @param db - The database contract/service to use for queries
-     */
-    constructor(db: DatabaseContract);
-    /**
-     * Maps a database row to an entity instance
-     *
-     * @param row - Raw database row
-     * @returns The mapped entity
-     */
-    protected abstract toEntity(row: any): TEntity;
-    /**
-     * Maps an entity to a database row
-     *
-     * @param entity - The entity to map
-     * @returns Object suitable for database operations
-     */
-    protected abstract toRow(entity: TEntity): Record<string, any>;
-    /**
-     * Find an entity by its primary key
-     *
-     * @param id - The primary key value
-     * @returns The entity or null if not found
-     *
-     * @example
-     * ```typescript
-     * const user = await userRepo.findById(1)
-     * if (user) {
-     *   console.log(user.name)
-     * }
-     * ```
-     */
-    findById(id: TId): Promise<TEntity | null>;
-    /**
-     * Find a single entity matching the given conditions
-     *
-     * @param where - Conditions to match (equality only)
-     * @returns The first matching entity or null
-     *
-     * @example
-     * ```typescript
-     * const user = await userRepo.findOne({ email: 'john@example.com' })
-     * ```
-     */
-    findOne(where: WhereCondition<TEntity>): Promise<TEntity | null>;
-    /**
-     * Find multiple entities with optional filtering, pagination, and ordering
-     *
-     * @param where - Optional conditions to filter by
-     * @param options - Query options (select, orderBy, limit, offset)
-     * @returns Result containing data array and optional total count
-     *
-     * @example
-     * ```typescript
-     * // Simple query
-     * const { data: users } = await userRepo.findMany({ active: true })
-     *
-     * // With pagination and ordering
-     * const result = await userRepo.findMany(
-     *   { role: 'admin' },
-     *   { limit: 10, offset: 20, orderBy: { createdAt: 'DESC' } }
-     * )
-     * console.log(`Page of ${result.data.length} admins`)
-     * ```
-     */
-    findMany(where?: WhereCondition<TEntity>, options?: FindOptions<TEntity>): Promise<FindManyResult<TEntity>>;
-    /**
-     * Count entities matching the given conditions
-     *
-     * @param where - Optional conditions to filter by
-     * @returns The count of matching entities
-     *
-     * @example
-     * ```typescript
-     * const activeCount = await userRepo.count({ active: true })
-     * ```
-     */
-    count(where?: WhereCondition<TEntity>): Promise<number>;
-    /**
-     * Save an entity (insert if new, update if exists)
-     *
-     * If the entity has a primary key value, it will be updated.
-     * Otherwise, a new record will be inserted.
-     *
-     * @param entity - The entity to save
-     * @returns The saved entity with updated ID (for inserts)
-     *
-     * @example
-     * ```typescript
-     * // Insert new user
-     * const newUser = await userRepo.save({ name: 'John', email: 'john@example.com' })
-     * console.log(newUser.id) // Generated ID
-     *
-     * // Update existing user
-     * user.name = 'John Doe'
-     * await userRepo.save(user)
-     * ```
-     */
-    save(entity: TEntity): Promise<TEntity>;
-    /**
-     * Delete an entity by its primary key
-     *
-     * @param id - The primary key of the entity to delete
-     * @returns true if deleted, false if not found
-     *
-     * @example
-     * ```typescript
-     * const deleted = await userRepo.delete(1)
-     * if (deleted) {
-     *   console.log('User deleted')
-     * }
-     * ```
-     */
-    delete(id: TId): Promise<boolean>;
-    /**
-     * Delete entities matching the given conditions
-     *
-     * @param where - Conditions to match for deletion
-     * @returns Number of deleted entities
-     *
-     * @example
-     * ```typescript
-     * const count = await userRepo.deleteWhere({ active: false })
-     * console.log(`Deleted ${count} inactive users`)
-     * ```
-     */
-    deleteWhere(where: WhereCondition<TEntity>): Promise<number>;
-    /**
-     * Update an entity by ID
-     */
-    protected update(id: TId, row: Record<string, any>): Promise<void>;
-    /**
-     * Insert a new row and return the inserted ID
-     */
-    protected insertRow(row: Record<string, any>): Promise<TId>;
-    /**
-     * Build SELECT clause from field selection
-     */
-    protected buildSelectClause(select?: (keyof TEntity)[]): string;
-    /**
-     * Build WHERE clause from conditions
-     */
-    protected buildWhereClause(where?: WhereCondition<TEntity>): {
-        clause: string;
-        params: any[];
-    };
-    /**
-     * Build ORDER BY clause from orderBy options
-     */
-    protected buildOrderClause(orderBy?: Partial<Record<keyof TEntity, OrderDirection>>): string;
-    /**
-     * Build LIMIT/OFFSET clause
-     */
-    protected buildLimitClause(limit?: number, offset?: number): string;
-}