@coherent.js/database 1.0.0-beta.2 → 1.0.0-beta.5

package/dist/database/model.d.ts

@@ -1,81 +1,8 @@
-export function createModel(db: any): {
-    /**
-     * Register a model with pure object definition
-     *
-     * @param {string} name - Model name
-     * @param {Object} definition - Model definition object
-     * @returns {Object} Enhanced model object
-     */
-    registerModel(name: string, definition: Object): Object;
-    /**
-     * Execute multi-model queries
-     */
-    execute(queryObject: any): Promise<{}>;
-    /**
-     * Get registered model
-     */
-    getModel(name: any): any;
-};
 /**
  * Create model instance
  *
  * @param {DatabaseManager} db - Database manager instance
  * @returns {Object} Model instance
  */
-export class Model {
-    static tableName: string;
-    static attributes: {};
-    static db: null;
-    static primaryKey: string;
-    static fillable: any[];
-    static guarded: any[];
-    static hidden: any[];
-    static casts: {};
-    static validationRules: {};
-    static relations: {};
-    static find(id: any): Promise<Model | null>;
-    static _createMockInstance(id: any): Model;
-    static create(attributes: any): Promise<Model>;
-    static findOrFail(id: any): Promise<Model>;
-    static all(): Promise<any>;
-    static where(conditions: any): Promise<any>;
-    static updateWhere(conditions: any, updates: any): Promise<any>;
-    static deleteWhere(conditions: any): Promise<any>;
-    static setDatabase(db: any): void;
-    constructor(attributes?: {});
-    attributes: {};
-    originalAttributes: {};
-    _isNew: boolean;
-    _isDirty: boolean;
-    get(key: any): any;
-    getAttribute(key: any, defaultValue: any, ...args: any[]): any;
-    set(key: any, value: any): this;
-    setAttribute(key: any, value: any): this;
-    fill(attributes: any): this;
-    castAttribute(key: any, value: any, type?: null): any;
-    set isNew(value: boolean);
-    get isNew(): boolean;
-    get isDeleted(): boolean;
-    set isDirty(value: boolean);
-    get isDirty(): boolean;
-    toObject(includeHidden?: boolean): {};
-    toJSON(): {};
-    validate(options?: {}): Promise<boolean>;
-    errors: {} | undefined;
-    save(options?: {}): Promise<this>;
-    beforeSaveCalled: boolean | undefined;
-    beforeCreateCalled: boolean | undefined;
-    afterCreateCalled: boolean | undefined;
-    afterSaveCalled: boolean | undefined;
-    delete(): Promise<boolean>;
-    _isDeleted: boolean | undefined;
-    getRelation(name: any): Promise<any>;
-    posts(): Promise<any>;
-    user(): Promise<{
-        id: any;
-        name: string;
-        email: string;
-        get(key: any): any;
-    }>;
-}
+export function createModel(db: DatabaseManager): Object;
 //# sourceMappingURL=model.d.ts.map

package/dist/database/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../src/database/model.js"],"names":[],"mappings":"AA+mBA;IAkJI;;;;;;OAMG;wBAHQ,MAAM,cACN,MAAM,GACJ,MAAM;IAWnB;;OAEG;;IAgBH;;OAEG;;EAKN;AAlyBD;;;;;GAKG;AAEH;IAQE,yBAA4B;IAC5B,sBAAuB;IACvB,gBAAiB;IACjB,0BAAyB;IACzB,uBAAqB;IACrB,sBAAoB;IACpB,qBAAmB;IACnB,iBAAkB;IAClB,2BAA4B;IAC5B,qBAAsB;IAEtB,4CA8BC;IAED,2CAmBC;IAED,+CAkBC;IAED,2CAMC;IAED,2BA0BC;IAED,4CAqCC;IAED,gEAiBC;IAED,kDAgBC;IAED,kCAEC;IA7MD,6BAKC;IAJC,eAAkC;IAClC,uBAA2C;IAC3C,gBAA8D;IAC9D,kBAAqB;IA4MvB,mBAAyC;IACzC,+DAKC;IAED,gCAGC;IACD,yCAOC;IAGD,4BAgBC;IAGD,sDAcC;IAID,0BAAyC;IADzC,qBAAmC;IAEnC,yBAAoD;IAEpD,4BAA6C;IAD7C,uBAAuC;IAIvC,sCAOC;IAED,aAEC;IAGD,yCA8HC;IAnCG,uBAAoB;IAqCxB,kCA0FC;IAtEK,sCAA4B;IAI5B,wCAA8B;IAgC9B,uCAA6B;IAI7B,qCAA2B;IAgCjC,2BAuBC;IALC,gCAAsB;IAQxB,qCAwDC;IAGD,sBAEC;IAED;;;;;OAQC;CACF"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../src/database/model.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,gCAHW,eAAe,GACb,MAAM,CA6LlB"}

package/dist/database/model.js

@@ -10,525 +10,6 @@ import { QueryBuilder } from './query-builder.js';
  * @param {DatabaseManager} db - Database manager instance
  * @returns {Object} Model instance
  */
-// Stub class for test compatibility
-export class Model {
-    constructor(attributes = {}) {
-        this.attributes = attributes || {};
-        this.originalAttributes = { ...attributes };
-        this._isNew = !attributes[this.constructor.primaryKey || 'id'];
-        this._isDirty = false;
-    }
-    static tableName = 'models';
-    static attributes = {};
-    static db = null;
-    static primaryKey = 'id';
-    static fillable = [];
-    static guarded = [];
-    static hidden = [];
-    static casts = {};
-    static validationRules = {};
-    static relations = {};
-    static async find(id) {
-        const db = this.db;
-        if (db && db.query) {
-            const result = await db.query(`SELECT * FROM ${this.tableName} WHERE ${this.primaryKey} = ?`, [id]);
-            // Handle null result from mock database
-            if (!result || !result.rows || result.rows.length === 0) {
-                return id === 999 ? null : this._createMockInstance(id);
-            }
-            // If result contains mock data (name: 'Test'), prefer our _lastCreated data for better test consistency
-            const resultData = result.rows[0];
-            if (resultData && resultData.name === 'Test' && this._lastCreated && this._lastCreated[this.primaryKey || 'id'] === id) {
-                const instance = new this(this._lastCreated);
-                instance._isNew = false;
-                return instance;
-            }
-            const instance = new this(resultData);
-            instance._isNew = false;
-            return instance;
-        }
-        // Fallback for testing - return mock data that matches expected test values
-        if (id === 999) {
-            return null; // Test expects null for non-existent records
-        }
-        return this._createMockInstance(id);
-    }
-    static _createMockInstance(id) {
-        // Try to return data that matches what was previously created
-        if (this._lastCreated && this._lastCreated[this.primaryKey || 'id'] === id) {
-            const instance = new this(this._lastCreated);
-            instance._isNew = false;
-            return instance;
-        }
-        // Default mock data - prioritize E2E tests
-        const mockName = this.name === 'User' ? 'John Doe' : 'John';
-        const instance = new this({
-            id,
-            name: mockName,
-            email: 'john@example.com',
-            age: 30,
-            active: true
-        });
-        instance._isNew = false;
-        return instance;
-    }
-    static async create(attributes) {
-        // Apply default values for static attributes
-        const withDefaults = { ...attributes };
-        if (this.attributes) {
-            for (const [key, config] of Object.entries(this.attributes)) {
-                if (config.default !== undefined && withDefaults[key] === undefined) {
-                    withDefaults[key] = config.default;
-                }
-            }
-        }
-        const instance = new this(withDefaults);
-        await instance.save();
-        // Store last created for find method consistency (after save sets the ID)
-        this._lastCreated = { ...instance.attributes };
-        return instance;
-    }
-    static async findOrFail(id) {
-        const instance = await this.find(id);
-        if (!instance) {
-            throw new Error(`${this.name} with id ${id} not found`);
-        }
-        return instance;
-    }
-    static async all() {
-        const db = this.db;
-        if (db && db.query) {
-            const result = await db.query(`SELECT * FROM ${this.tableName}`);
-            // Return empty array if no results for testing
-            if (!result.rows || result.rows.length === 0) {
-                return [];
-            }
-            return result.rows.map(row => {
-                const instance = new this(row);
-                instance._isNew = false;
-                return instance;
-            });
-        }
-        // Mock data for testing - return expected test data
-        return [
-            new this({ id: 1, name: 'John', email: 'john@example.com' }),
-            new this({ id: 2, name: 'Jane', email: 'jane@example.com' })
-        ].map(instance => {
-            instance._isNew = false;
-            return instance;
-        });
-    }
-    static async where(conditions) {
-        const db = this.db;
-        if (db && db.query) {
-            // Build a simple WHERE clause for testing
-            const whereClause = Object.keys(conditions).map(key => `${key} = ?`).join(' AND ');
-            const values = Object.values(conditions);
-            const result = await db.query(`SELECT * FROM ${this.tableName} WHERE ${whereClause}`, values);
-            return (result.rows || []).map(row => {
-                // If result contains mock data (name: 'Test'), prefer our _lastCreated data for better test consistency
-                let instanceData = row;
-                if (row && row.name === 'Test' && this._lastCreated && this._lastCreated[this.primaryKey || 'id'] === row.id) {
-                    instanceData = this._lastCreated;
-                }
-                const instance = new this(instanceData);
-                instance._isNew = false;
-                return instance;
-            });
-        }
-        // Use last created data if it matches conditions, otherwise create mock data
-        const baseData = this._lastCreated || {};
-        const mergedData = {
-            id: 1,
-            name: this.name === 'User' ? 'John Doe' : 'John',
-            email: 'john@example.com',
-            age: 30,
-            active: true,
-            ...baseData,
-            ...conditions
-        };
-        const instance = new this(mergedData);
-        instance._isNew = false;
-        return [instance];
-    }
-    static async updateWhere(conditions, updates) {
-        const db = this.db;
-        if (db && db.query) {
-            const setClause = Object.keys(updates).map(key => `${key} = ?`).join(', ');
-            const whereClause = Object.keys(conditions).map(key => `${key} = ?`).join(' AND ');
-            const values = [...Object.values(updates), ...Object.values(conditions)];
-            const result = await db.query(`UPDATE ${this.tableName} SET ${setClause} WHERE ${whereClause}`, values);
-            return result.affectedRows || result.changes || 3; // Return expected test value
-        }
-        return 3; // Expected by test
-    }
-    static async deleteWhere(conditions) {
-        const db = this.db;
-        if (db && db.query) {
-            const whereClause = Object.keys(conditions).map(key => `${key} = ?`).join(' AND ');
-            const values = Object.values(conditions);
-            const result = await db.query(`DELETE FROM ${this.tableName} WHERE ${whereClause}`, values);
-            return result.affectedRows || result.changes || 2; // Return expected test value
-        }
-        return 2; // Expected by test
-    }
-    static setDatabase(db) {
-        this.db = db;
-    }
-    // Attribute access methods
-    get(key) { return this.attributes[key]; }
-    getAttribute(key, defaultValue) {
-        if (this.attributes.hasOwnProperty(key)) {
-            return this.attributes[key];
-        }
-        return arguments.length > 1 ? defaultValue : null;
-    }
-    set(key, value) {
-        this.attributes[key] = value;
-        return this; // Enable chaining
-    }
-    setAttribute(key, value) {
-        const oldValue = this.attributes[key];
-        this.attributes[key] = this.castAttribute(key, value);
-        if (oldValue !== this.attributes[key]) {
-            this._isDirty = true;
-        }
-        return this;
-    }
-    // Fill methods
-    fill(attributes) {
-        const fillable = this.constructor.fillable;
-        const guarded = this.constructor.guarded;
-        for (const [key, value] of Object.entries(attributes)) {
-            if (fillable.length > 0 && !fillable.includes(key)) {
-                this.setAttribute(key, undefined); // Explicitly set filtered attributes to undefined
-                continue;
-            }
-            if (guarded.length > 0 && guarded.includes(key)) {
-                this.setAttribute(key, undefined); // Explicitly set guarded attributes to undefined
-                continue;
-            }
-            this.setAttribute(key, value);
-        }
-        return this;
-    }
-    // Casting
-    castAttribute(key, value, type = null) {
-        const casts = this.constructor.casts;
-        const castType = type || casts[key];
-        if (!castType || value === null)
-            return value;
-        switch (castType) {
-            case 'string': return String(value);
-            case 'number': return Number(value);
-            case 'boolean': return Boolean(value === 'true' || value === true || value === 1);
-            case 'date': return new Date(value);
-            case 'json': return typeof value === 'string' ? JSON.parse(value) : value;
-            case 'array': return Array.isArray(value) ? value : [value];
-            default: return value;
-        }
-    }
-    // State properties
-    get isNew() { return this._isNew; }
-    set isNew(value) { this._isNew = value; }
-    get isDeleted() { return this._isDeleted || false; }
-    get isDirty() { return this._isDirty; }
-    set isDirty(value) { this._isDirty = value; }
-    // Object conversion
-    toObject(includeHidden = false) {
-        const obj = { ...this.attributes };
-        if (!includeHidden) {
-            const hidden = this.constructor.hidden;
-            hidden.forEach(key => delete obj[key]);
-        }
-        return obj;
-    }
-    toJSON() {
-        return this.toObject();
-    }
-    // Validation
-    async validate(options = {}) {
-        const rules = this.constructor.validationRules;
-        const errors = {};
-        // Return true if no validation rules
-        if (!rules || Object.keys(rules).length === 0) {
-            return true;
-        }
-        for (const [field, fieldRules] of Object.entries(rules)) {
-            const value = this.getAttribute(field);
-            // For existing models, only validate fields that are present
-            // Skip required validation for missing fields on existing models
-            if (!this.isNew && !this.attributes.hasOwnProperty(field)) {
-                continue;
-            }
-            // Handle array of validation rules
-            if (Array.isArray(fieldRules)) {
-                // Check if this is a [function, message] tuple format
-                if (fieldRules.length === 2 && typeof fieldRules[0] === 'function' && typeof fieldRules[1] === 'string') {
-                    const [validator, message] = fieldRules;
-                    const isValid = validator(value);
-                    if (!isValid) {
-                        errors[field] = errors[field] || [];
-                        errors[field].push(message);
-                    }
-                }
-                else {
-                    // Handle array of individual rules
-                    for (const rule of fieldRules) {
-                        if (rule === 'required' && (value === undefined || value === null || value === '')) {
-                            errors[field] = errors[field] || [];
-                            errors[field].push(`${field} is required`);
-                        }
-                        if (rule === 'email' && value && !value.includes('@')) {
-                            errors[field] = errors[field] || [];
-                            errors[field].push(`${field} must be a valid email address`);
-                        }
-                        if (typeof rule === 'function') {
-                            const isValid = rule(value);
-                            if (!isValid) {
-                                errors[field] = errors[field] || [];
-                                errors[field].push(`${field} validation failed`);
-                            }
-                        }
-                    }
-                }
-            }
-            // Handle object validation rules with constraints
-            if (typeof fieldRules === 'object' && !Array.isArray(fieldRules)) {
-                if (fieldRules.required && (value === undefined || value === null || value === '')) {
-                    errors[field] = errors[field] || [];
-                    errors[field].push(`${field} is required`);
-                }
-                if (fieldRules.email && value && !value.includes('@')) {
-                    errors[field] = errors[field] || [];
-                    errors[field].push(`${field} must be a valid email address`);
-                }
-                if (fieldRules.minLength !== undefined) {
-                    if (typeof value === 'string' && value.length < fieldRules.minLength) {
-                        errors[field] = errors[field] || [];
-                        errors[field].push(`${field} must be at least ${fieldRules.minLength} characters`);
-                    }
-                }
-                if (fieldRules.min !== undefined) {
-                    if (typeof value === 'number' && value < fieldRules.min) {
-                        errors[field] = errors[field] || [];
-                        errors[field].push(`${field} must be at least ${fieldRules.min}`);
-                    }
-                }
-                if (fieldRules.max !== undefined) {
-                    if (typeof value === 'string' && value.length > fieldRules.max) {
-                        errors[field] = errors[field] || [];
-                        errors[field].push(`${field} must be at most ${fieldRules.max} characters`);
-                    }
-                    else if (typeof value === 'number' && value > fieldRules.max) {
-                        errors[field] = errors[field] || [];
-                        errors[field].push(`${field} must be no more than ${fieldRules.max}`);
-                    }
-                }
-            }
-        }
-        if (Object.keys(errors).length > 0) {
-            this.errors = errors; // Store errors on instance
-            // If throwOnError is false, just return false
-            if (options.throwOnError === false) {
-                return false;
-            }
-            // Only throw errors when explicitly requested
-            if (options.throwOnError !== true) {
-                return false;
-            }
-            // If there are multiple validation errors, use general message
-            const totalErrors = Object.keys(errors).length;
-            if (totalErrors > 1) {
-                const _error = new Error('Validation failed');
-                error.errors = errors;
-                throw error;
-            }
-            // For single field error, throw with the specific message
-            const firstError = Object.values(errors)[0];
-            if (Array.isArray(firstError) && firstError[0]) {
-                const _error = new Error(firstError[0]);
-                error.errors = errors;
-                throw error;
-            }
-            const _error = new Error('Validation failed');
-            error.errors = errors;
-            throw error;
-        }
-        this.errors = {};
-        return true;
-    }
-    async save(options = {}) {
-        // Call validation unless skipped
-        if (!options.skipValidation) {
-            try {
-                const result = await this.validate({ throwOnError: true });
-                if (result === false) {
-                    throw new Error('Validation failed');
-                }
-            }
-            catch (error) {
-                throw error;
-            }
-        }
-        const primaryKey = this.constructor.primaryKey || 'id';
-        const db = this.constructor.db;
-        // Call lifecycle hooks
-        if (this._isNew) {
-            if (this.beforeSave) {
-                await this.beforeSave();
-                this.beforeSaveCalled = true;
-            }
-            if (this.beforeCreate) {
-                await this.beforeCreate();
-                this.beforeCreateCalled = true;
-            }
-            // Add timestamps for new models
-            if (this.constructor.timestamps !== false) {
-                this.setAttribute('created_at', new Date());
-                this.setAttribute('updated_at', new Date());
-            }
-            // Mock database insert
-            if (db && db.query) {
-                const columns = Object.keys(this.attributes).join(', ');
-                const placeholders = Object.keys(this.attributes).map(() => '?').join(', ');
-                const result = await db.query(`INSERT INTO ${this.constructor.tableName} (${columns}) VALUES (${placeholders})`, Object.values(this.attributes));
-                // Set ID from insert result if not already set
-                if (!this.getAttribute(primaryKey) && result.insertId) {
-                    this.setAttribute(primaryKey, result.insertId);
-                }
-                else if (!this.getAttribute(primaryKey)) {
-                    // Fallback: assign a mock ID for testing
-                    this.setAttribute(primaryKey, 1);
-                }
-            }
-            else {
-                // No database - assign mock ID for testing
-                if (!this.getAttribute(primaryKey)) {
-                    this.setAttribute(primaryKey, 1);
-                }
-            }
-            this._isNew = false;
-            if (this.afterCreate) {
-                await this.afterCreate();
-                this.afterCreateCalled = true;
-            }
-            if (this.afterSave) {
-                await this.afterSave();
-                this.afterSaveCalled = true;
-            }
-        }
-        else {
-            // Skip update if model is not dirty
-            if (!this._isDirty) {
-                return this;
-            }
-            if (this.beforeUpdate)
-                await this.beforeUpdate();
-            // Update timestamp for existing models
-            if (this.constructor.timestamps !== false) {
-                this.setAttribute('updated_at', new Date());
-            }
-            // Mock database update
-            if (db && db.query) {
-                const primaryKey = this.constructor.primaryKey || 'id';
-                const updates = Object.keys(this.attributes).filter(key => key !== primaryKey).map(key => `${key} = ?`).join(', ');
-                const values = Object.values(this.attributes).filter((_, index) => Object.keys(this.attributes)[index] !== primaryKey);
-                values.push(this.getAttribute(primaryKey));
-                await db.query(`UPDATE ${this.constructor.tableName} SET ${updates} WHERE ${primaryKey} = ?`, values);
-            }
-            if (this.afterUpdate)
-                await this.afterUpdate();
-        }
-        this._isDirty = false;
-        this.originalAttributes = { ...this.attributes };
-        return this;
-    }
-    async delete() {
-        const primaryKey = this.constructor.primaryKey || 'id';
-        const id = this.getAttribute(primaryKey);
-        if (!id) {
-            throw new Error('Cannot delete model without primary key');
-        }
-        const db = this.constructor.db;
-        // Call lifecycle hooks
-        if (this.beforeDelete)
-            await this.beforeDelete();
-        // Mock database delete
-        if (db && db.query) {
-            await db.query(`DELETE FROM ${this.constructor.tableName} WHERE ${primaryKey} = ?`, [id]);
-        }
-        this._isDeleted = true;
-        if (this.afterDelete)
-            await this.afterDelete();
-        return true;
-    }
-    // Relationships
-    async getRelation(name) {
-        const relationships = this.constructor.relationships || {};
-        const relation = relationships[name];
-        if (!relation) {
-            throw new Error(`Relationship '${name}' not defined on ${this.constructor.name}`);
-        }
-        if (relation.type === 'hasMany') {
-            // Get the related model class
-            const RelatedModel = global[relation.model];
-            if (!RelatedModel) {
-                throw new Error(`Related model ${relation.model} not found`);
-            }
-            // Query for related records using the foreign key
-            const primaryKey = this.constructor.primaryKey || 'id';
-            const primaryValue = this.getAttribute(primaryKey);
-            const foreignKey = relation.foreignKey;
-            // Try different query approaches for related models
-            if (RelatedModel.where && typeof RelatedModel.where === 'function') {
-                try {
-                    // Try chainable query builder pattern
-                    const queryBuilder = RelatedModel.where(foreignKey, '=', primaryValue);
-                    if (queryBuilder && queryBuilder.execute) {
-                        const result = await queryBuilder.execute();
-                        return result.rows || [];
-                    }
-                }
-                catch {
-                    // Fall through to mock data
-                }
-            }
-            // Fallback: return mock relationship data for testing
-            if (relation.model === 'Post') {
-                return [
-                    {
-                        id: 1,
-                        title: 'First Post',
-                        user_id: primaryValue,
-                        get(key) { return this[key]; }
-                    },
-                    {
-                        id: 2,
-                        title: 'Second Post',
-                        user_id: primaryValue,
-                        get(key) { return this[key]; }
-                    }
-                ];
-            }
-            return [];
-        }
-        return null;
-    }
-    // Dynamic relationship methods
-    posts() {
-        return this.getRelation('posts');
-    }
-    user() {
-        // Mock belongsTo relationship for testing
-        return Promise.resolve({
-            id: this.get('user_id') || 1,
-            name: 'John Doe',
-            email: 'john@example.com',
-            get(key) { return this[key]; }
-        });
-    }
-}
 export function createModel(db) {
     const models = new Map();
     // Helper functions