@open-core/framework 0.2.8 → 0.3.0

package/dist/runtime/server/contracts/repository/repository.contract.js

@@ -1,341 +0,0 @@
-"use strict";
-/**
- * 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' } })
- * ```
- */
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
-/**
- * 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)
- */
-class Repository {
-    /**
-     * Creates a new repository instance
-     *
-     * @param db - The database contract/service to use for queries
-     */
-    constructor(db) {
-        this.db = db;
-        /**
-         * The primary key column name (defaults to 'id')
-         */
-        this.primaryKey = 'id';
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // CRUD Operations
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * 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)
-     * }
-     * ```
-     */
-    async findById(id) {
-        const sql = `SELECT * FROM ${this.tableName} WHERE ${this.primaryKey} = ?`;
-        const row = await this.db.single(sql, [id]);
-        return row ? this.toEntity(row) : 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' })
-     * ```
-     */
-    async findOne(where) {
-        const { clause, params } = this.buildWhereClause(where);
-        const sql = `SELECT * FROM ${this.tableName}${clause} LIMIT 1`;
-        const row = await this.db.single(sql, params);
-        return row ? this.toEntity(row) : 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`)
-     * ```
-     */
-    async findMany(where, options) {
-        const selectClause = this.buildSelectClause(options === null || options === void 0 ? void 0 : options.select);
-        const { clause: whereClause, params } = this.buildWhereClause(where);
-        const orderClause = this.buildOrderClause(options === null || options === void 0 ? void 0 : options.orderBy);
-        const limitClause = this.buildLimitClause(options === null || options === void 0 ? void 0 : options.limit, options === null || options === void 0 ? void 0 : options.offset);
-        const sql = `SELECT ${selectClause} FROM ${this.tableName}${whereClause}${orderClause}${limitClause}`;
-        const rows = await this.db.query(sql, params);
-        const data = rows.map((row) => this.toEntity(row));
-        // If pagination is used, also get total count
-        let total;
-        if ((options === null || options === void 0 ? void 0 : options.limit) !== undefined) {
-            total = await this.count(where);
-        }
-        return { data, total };
-    }
-    /**
-     * 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 })
-     * ```
-     */
-    async count(where) {
-        const { clause, params } = this.buildWhereClause(where);
-        const sql = `SELECT COUNT(*) as count FROM ${this.tableName}${clause}`;
-        const result = await this.db.scalar(sql, params);
-        return result !== null && result !== void 0 ? result : 0;
-    }
-    /**
-     * 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)
-     * ```
-     */
-    async save(entity) {
-        const row = this.toRow(entity);
-        const id = row[this.primaryKey];
-        if (id !== undefined && id !== null) {
-            // Update existing entity
-            await this.update(id, row);
-            return entity;
-        }
-        else {
-            // Insert new entity
-            const insertedId = await this.insertRow(row);
-            // Return entity with the new ID
-            return this.toEntity(Object.assign(Object.assign({}, row), { [this.primaryKey]: insertedId }));
-        }
-    }
-    /**
-     * 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')
-     * }
-     * ```
-     */
-    async delete(id) {
-        const sql = `DELETE FROM ${this.tableName} WHERE ${this.primaryKey} = ?`;
-        const result = await this.db.execute(sql, [id]);
-        return result.affectedRows > 0;
-    }
-    /**
-     * 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`)
-     * ```
-     */
-    async deleteWhere(where) {
-        const { clause, params } = this.buildWhereClause(where);
-        if (!clause) {
-            throw new Error('deleteWhere requires at least one condition to prevent accidental full table deletion');
-        }
-        const sql = `DELETE FROM ${this.tableName}${clause}`;
-        const result = await this.db.execute(sql, params);
-        return result.affectedRows;
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Protected Helper Methods
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Update an entity by ID
-     */
-    async update(id, row) {
-        const _a = row, _b = this.primaryKey, _ = _a[_b], updateData = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-        const columns = Object.keys(updateData);
-        const setClause = columns.map((col) => `${col} = ?`).join(', ');
-        const values = columns.map((col) => updateData[col]);
-        const sql = `UPDATE ${this.tableName} SET ${setClause} WHERE ${this.primaryKey} = ?`;
-        await this.db.execute(sql, [...values, id]);
-    }
-    /**
-     * Insert a new row and return the inserted ID
-     */
-    async insertRow(row) {
-        const _a = row, _b = this.primaryKey, _ = _a[_b], insertData = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-        const columns = Object.keys(insertData);
-        const placeholders = columns.map(() => '?').join(', ');
-        const values = columns.map((col) => insertData[col]);
-        const sql = `INSERT INTO ${this.tableName} (${columns.join(', ')}) VALUES (${placeholders})`;
-        const result = await this.db.insert(sql, values);
-        return result.insertId;
-    }
-    /**
-     * Build SELECT clause from field selection
-     */
-    buildSelectClause(select) {
-        if (!select || select.length === 0) {
-            return '*';
-        }
-        return select.map((field) => String(field)).join(', ');
-    }
-    /**
-     * Build WHERE clause from conditions
-     */
-    buildWhereClause(where) {
-        if (!where || Object.keys(where).length === 0) {
-            return { clause: '', params: [] };
-        }
-        const conditions = [];
-        const params = [];
-        for (const [key, value] of Object.entries(where)) {
-            if (value === null) {
-                conditions.push(`${key} IS NULL`);
-            }
-            else if (value === undefined) {
-            }
-            else {
-                conditions.push(`${key} = ?`);
-                params.push(value);
-            }
-        }
-        if (conditions.length === 0) {
-            return { clause: '', params: [] };
-        }
-        return {
-            clause: ` WHERE ${conditions.join(' AND ')}`,
-            params,
-        };
-    }
-    /**
-     * Build ORDER BY clause from orderBy options
-     */
-    buildOrderClause(orderBy) {
-        if (!orderBy || Object.keys(orderBy).length === 0) {
-            return '';
-        }
-        const orders = Object.entries(orderBy)
-            .filter(([_, direction]) => direction)
-            .map(([field, direction]) => `${field} ${direction}`);
-        if (orders.length === 0) {
-            return '';
-        }
-        return ` ORDER BY ${orders.join(', ')}`;
-    }
-    /**
-     * Build LIMIT/OFFSET clause
-     */
-    buildLimitClause(limit, offset) {
-        if (limit === undefined) {
-            return '';
-        }
-        let clause = ` LIMIT ${limit}`;
-        if (offset !== undefined && offset > 0) {
-            clause += ` OFFSET ${offset}`;
-        }
-        return clause;
-    }
-}
-exports.Repository = Repository;

package/dist/runtime/server/contracts/repository/repository.types.d.ts

@@ -1,51 +0,0 @@
-/**
- * Repository Pattern Types
- *
- * Types and interfaces for the generic repository pattern.
- */
-/**
- * Sort direction for orderBy clauses
- */
-export type OrderDirection = 'ASC' | 'DESC';
-/**
- * Options for findMany queries with pagination, ordering, and field selection
- *
- * @example
- * ```typescript
- * const options: FindOptions<User> = {
- *   select: ['id', 'name', 'email'],
- *   orderBy: { createdAt: 'DESC' },
- *   limit: 10,
- *   offset: 0
- * }
- * ```
- */
-export interface FindOptions<TEntity> {
-    /** Fields to select (SELECT clause). If omitted, selects all fields (*) */
-    select?: (keyof TEntity)[];
-    /** Order by fields with direction */
-    orderBy?: Partial<Record<keyof TEntity, OrderDirection>>;
-    /** Maximum number of records to return */
-    limit?: number;
-    /** Number of records to skip (for pagination) */
-    offset?: number;
-}
-/**
- * Result of a findMany query with optional total count for pagination
- *
- * @example
- * ```typescript
- * const result = await userRepo.findMany({}, { limit: 10 })
- * console.log(`Showing ${result.data.length} of ${result.total} users`)
- * ```
- */
-export interface FindManyResult<TEntity> {
-    /** Array of entities matching the query */
-    data: TEntity[];
-    /** Total count of matching records (useful for pagination) */
-    total?: number;
-}
-/**
- * Where clause condition - partial entity for simple equality matching
- */
-export type WhereCondition<TEntity> = Partial<TEntity>;

package/dist/runtime/server/contracts/repository/repository.types.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * Repository Pattern Types
- *
- * Types and interfaces for the generic repository pattern.
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/server/database/adapter.registry.d.ts

@@ -1,4 +0,0 @@
-import { DatabaseContract } from './database.contract';
-export type DatabaseAdapterFactoryFn = () => DatabaseContract;
-export declare function registerDatabaseAdapterFactory(name: string, factory: DatabaseAdapterFactoryFn): void;
-export declare function resolveDatabaseAdapterFactory(name: string): DatabaseAdapterFactoryFn | undefined;

package/dist/runtime/server/database/adapter.registry.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerDatabaseAdapterFactory = registerDatabaseAdapterFactory;
-exports.resolveDatabaseAdapterFactory = resolveDatabaseAdapterFactory;
-const factories = new Map();
-function registerDatabaseAdapterFactory(name, factory) {
-    if (factories.has(name)) {
-        throw new Error(`[OpenCore] Database adapter factory '${name}' is already registered`);
-    }
-    factories.set(name, factory);
-}
-function resolveDatabaseAdapterFactory(name) {
-    return factories.get(name);
-}

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

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

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

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