@arikajs/database 0.0.4 → 0.0.5

package/dist/Model/Model.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelQueryBuilder = exports.Model = void 0;
 const Database_1 = require("../Database");
 const Relations_1 = require("./Relations");
+const Observer_1 = require("./Observer");
+const GlobalScope_1 = require("./GlobalScope");
 /**
  * Base Model class for Active Record pattern
  */
@@ -32,11 +34,79 @@ class Model {
          * Loaded relationships
          */
         this.relations = {};
+        /**
+         * The attributes that should be hidden for serialization.
+         */
+        this.hidden = [];
+        /**
+         * The attributes that should be visible for serialization.
+         */
+        this.visible = [];
+        /**
+         * The attributes that should be cast to native types.
+         */
+        this.casts = {};
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (Reflect.has(target, prop)) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                if (typeof prop === 'string') {
+                    // Check if it's a loaded relationship first
+                    if (target.relations && prop in target.relations) {
+                        return target.relations[prop];
+                    }
+                    return target.getAttribute(prop);
+                }
+                return undefined;
+            },
+            set(target, prop, value, receiver) {
+                if (Reflect.has(target, prop)) {
+                    return Reflect.set(target, prop, value, receiver);
+                }
+                if (typeof prop === 'string') {
+                    target.setAttribute(prop, value);
+                    return true;
+                }
+                return false;
+            }
+        });
     }
     /**
      * Create a new query builder for the model
      */
     static query() {
+        const queryBuilder = Database_1.Database.table(this.getTableName(), this.getConnectionName());
+        const mqb = new ModelQueryBuilder(queryBuilder, this);
+        // Apply all registered global scopes
+        GlobalScope_1.GlobalScopeRegistry.applyAll(this.name, mqb, this);
+        return mqb;
+    }
+    /**
+     * Register an observer for this model
+     */
+    static observe(observer) {
+        Observer_1.ObserverRegistry.register(this.name, observer);
+    }
+    /**
+     * Add a global scope to this model
+     */
+    static addGlobalScope(name, scope) {
+        const resolvedScope = typeof scope === 'function'
+            ? new GlobalScope_1.CallbackGlobalScope(scope)
+            : scope;
+        GlobalScope_1.GlobalScopeRegistry.register(this.name, name, resolvedScope);
+    }
+    /**
+     * Remove a named global scope from this model
+     */
+    static removeGlobalScope(name) {
+        GlobalScope_1.GlobalScopeRegistry.remove(this.name, name);
+    }
+    /**
+     * Run a query without any global scopes
+     */
+    static withoutGlobalScopes() {
         const queryBuilder = Database_1.Database.table(this.getTableName(), this.getConnectionName());
         return new ModelQueryBuilder(queryBuilder, this);
     }
@@ -122,6 +192,12 @@ class Model {
     static async create(data) {
         return this.query().create(data);
     }
+    /**
+     * Insert a record or multiple records (Bulk Insert)
+     */
+    static async insert(data) {
+        return this.query().insert(data);
+    }
     /**
      * Get the first record
      */
@@ -134,12 +210,24 @@ class Model {
     static async get() {
         return this.query().get();
     }
+    /**
+     * Paginate the models
+     */
+    static async paginate(page = 1, perPage = 15) {
+        return this.query().paginate(page, perPage);
+    }
     /**
      * Get the count of records
      */
     static async count(column) {
         return this.query().count(column);
     }
+    /**
+     * Cache the query results
+     */
+    static cache(ttl, key) {
+        return this.query().cache(ttl, key);
+    }
     /**
      * Eager load relationships
      */
@@ -194,18 +282,109 @@ class Model {
         const constructor = this.constructor;
         return constructor.getPrimaryKeyName();
     }
+    // ==================== Casts & Mutators ====================
+    /**
+     * Convert string into studly case (e.g. first_name -> FirstName)
+     */
+    studly(value) {
+        return value.replace(/(?:^|_)(.)/g, (_, c) => c.toUpperCase());
+    }
+    /**
+     * Cast an attribute to a native type.
+     */
+    castAttribute(key, value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        const castType = this.casts[key];
+        if (!castType) {
+            return value;
+        }
+        switch (castType) {
+            case 'int':
+            case 'integer':
+                return parseInt(value, 10);
+            case 'real':
+            case 'float':
+            case 'double':
+                return parseFloat(value);
+            case 'string':
+                return String(value);
+            case 'bool':
+            case 'boolean':
+                return value === 'true' || value === '1' || value === 1 || value === true;
+            case 'object':
+            case 'array':
+            case 'json':
+                return typeof value === 'string' ? JSON.parse(value) : value;
+            case 'date':
+            case 'datetime':
+            case 'timestamp':
+                return new Date(value);
+            default:
+                return value;
+        }
+    }
+    /**
+     * Cast an attribute to a native type for DB.
+     */
+    castAttributeForSave(key, value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        const castType = this.casts[key];
+        // Always format dates even if not explicitly in casts for timestamps
+        if (value instanceof Date) {
+            return this.formatDate(value);
+        }
+        if (!castType) {
+            return value;
+        }
+        switch (castType) {
+            case 'object':
+            case 'array':
+            case 'json':
+                return typeof value === 'object' ? JSON.stringify(value) : value;
+            case 'date':
+            case 'datetime':
+            case 'timestamp':
+                return value instanceof Date ? this.formatDate(value) : value;
+            default:
+                return value;
+        }
+    }
+    /**
+     * Format a date for database and JSON serialization
+     */
+    formatDate(date) {
+        if (this.constructor.serializeDateAsUtc) {
+            return date.toISOString();
+        }
+        const pad = (n) => n.toString().padStart(2, '0');
+        return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+            `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+    }
     // ==================== Instance Methods ====================
     /**
      * Get an attribute value
      */
     getAttribute(key) {
-        return this.attributes[key];
+        const accessorMethod = `get${this.studly(key)}Attribute`;
+        if (typeof this[accessorMethod] === 'function') {
+            return this[accessorMethod](this.attributes[key]);
+        }
+        return this.castAttribute(key, this.attributes[key]);
     }
     /**
      * Set an attribute value
      */
     setAttribute(key, value) {
-        this.attributes[key] = value;
+        const mutatorMethod = `set${this.studly(key)}Attribute`;
+        if (typeof this[mutatorMethod] === 'function') {
+            this[mutatorMethod](value);
+            return;
+        }
+        this.attributes[key] = this.castAttributeForSave(key, value);
     }
     /**
      * Fill the model with an array of attributes
@@ -220,39 +399,67 @@ class Model {
      * Save the model to the database
      */
     async save() {
+        const modelName = this.constructor.name;
         const query = Database_1.Database.table(this.getTable(), this.getConnection());
         if (this.exists) {
-            // Update existing record
+            // Fire saving + updating events
+            if (await Observer_1.ObserverRegistry.fire(modelName, 'saving', this) === false)
+                return false;
+            if (await Observer_1.ObserverRegistry.fire(modelName, 'updating', this) === false)
+                return false;
             const primaryKey = this.getPrimaryKey();
             const id = this.attributes[primaryKey];
             if (!id) {
                 throw new Error('Cannot update model without primary key value');
             }
+            if (this.usesTimestamps()) {
+                this.updateTimestamps();
+            }
             const dirty = this.getDirty();
             if (Object.keys(dirty).length === 0) {
                 return true; // No changes to save
             }
             await query.where(primaryKey, id).update(dirty);
             this.syncOriginal();
+            // Fire saved + updated events
+            await Observer_1.ObserverRegistry.fire(modelName, 'updated', this);
+            await Observer_1.ObserverRegistry.fire(modelName, 'saved', this);
             return true;
         }
         else {
-            // Insert new record
+            // Fire saving + creating events
+            if (await Observer_1.ObserverRegistry.fire(modelName, 'saving', this) === false)
+                return false;
+            if (await Observer_1.ObserverRegistry.fire(modelName, 'creating', this) === false)
+                return false;
+            if (this.usesTimestamps()) {
+                this.updateTimestamps();
+            }
             const result = await query.insert(this.attributes);
-            // Set the primary key if it was auto-generated
             const primaryKey = this.getPrimaryKey();
             if (result && result.insertId && !this.attributes[primaryKey]) {
                 this.attributes[primaryKey] = result.insertId;
             }
             this.exists = true;
             this.syncOriginal();
+            // Fire created + saved events
+            await Observer_1.ObserverRegistry.fire(modelName, 'created', this);
+            await Observer_1.ObserverRegistry.fire(modelName, 'saved', this);
             return true;
         }
     }
+    /**
+     * Update the model with an array of attributes
+     */
+    async update(attributes) {
+        this.fill(attributes);
+        return await this.save();
+    }
     /**
      * Delete the model from the database
      */
-    async deleteInstance() {
+    async delete() {
+        const modelName = this.constructor.name;
         if (!this.exists) {
             return false;
         }
@@ -261,9 +468,14 @@ class Model {
         if (!id) {
             throw new Error('Cannot delete model without primary key value');
         }
+        // Fire deleting event
+        if (await Observer_1.ObserverRegistry.fire(modelName, 'deleting', this) === false)
+            return false;
         const query = Database_1.Database.table(this.getTable(), this.getConnection());
         await query.where(primaryKey, id).delete();
         this.exists = false;
+        // Fire deleted event
+        await Observer_1.ObserverRegistry.fire(modelName, 'deleted', this);
         return true;
     }
     /**
@@ -312,6 +524,24 @@ class Model {
     syncOriginal() {
         this.original = { ...this.attributes };
     }
+    /**
+     * Check if the model uses timestamps
+     */
+    usesTimestamps() {
+        return this.constructor.timestamps;
+    }
+    /**
+     * Update the model's timestamps
+     */
+    updateTimestamps() {
+        const now = new Date();
+        if (this.usesTimestamps()) {
+            this.setAttribute('updated_at', now);
+            if (!this.exists && !this.getAttribute('created_at')) {
+                this.setAttribute('created_at', now);
+            }
+        }
+    }
     /**
      * Mark the model as existing
      */
@@ -323,10 +553,42 @@ class Model {
      * Convert the model to a plain object
      */
     toJSON() {
-        return {
-            ...this.attributes,
-            ...this.relations,
+        let attributes = { ...this.attributes };
+        // Handle date formatting in attributes
+        for (const [key, value] of Object.entries(attributes)) {
+            if (value instanceof Date) {
+                attributes[key] = this.formatDate(value);
+            }
+        }
+        let relations = { ...this.relations };
+        // Handle date formatting in relations (recursive for nested models)
+        for (const [key, value] of Object.entries(relations)) {
+            if (value instanceof Model) {
+                relations[key] = value.toJSON();
+            }
+            else if (Array.isArray(value)) {
+                relations[key] = value.map(item => item instanceof Model ? item.toJSON() : item);
+            }
+        }
+        let result = {
+            ...attributes,
+            ...relations,
         };
+        // Filter hidden/visible attributes
+        if (this.visible.length > 0) {
+            result = Object.keys(result)
+                .filter(key => this.visible.includes(key))
+                .reduce((obj, key) => {
+                obj[key] = result[key];
+                return obj;
+            }, {});
+        }
+        else if (this.hidden.length > 0) {
+            this.hidden.forEach(key => {
+                delete result[key];
+            });
+        }
+        return result;
     }
     // ==================== Relationship Methods ====================
     /**
@@ -367,6 +629,52 @@ class Model {
         const rk = relatedKey || 'id';
         return new Relations_1.BelongsToMany(related, this, pivot, fpk, rpk, pk, rk);
     }
+    /**
+     * Define a has-one-through relationship
+     *
+     * Example: Country → hasOneThrough(Capital, Province, 'country_id', 'province_id')
+     */
+    hasOneThrough(related, through, firstKey, secondKey, localKey = 'id', secondLocalKey = 'id') {
+        const throughTable = through.table;
+        const fk = firstKey || `${this.getTable()}_id`;
+        const sk = secondKey || `${throughTable}_id`;
+        return new Relations_1.HasOneThrough(related, this, through, fk, sk, localKey, secondLocalKey);
+    }
+    /**
+     * Define a has-many-through relationship
+     *
+     * Example: Country → hasManyThrough(Post, User, 'country_id', 'user_id')
+     */
+    hasManyThrough(related, through, firstKey, secondKey, localKey = 'id', secondLocalKey = 'id') {
+        const throughTable = through.table;
+        const fk = firstKey || `${this.getTable()}_id`;
+        const sk = secondKey || `${throughTable}_id`;
+        return new Relations_1.HasManyThrough(related, this, through, fk, sk, localKey, secondLocalKey);
+    }
+    /**
+     * Define a polymorphic has-one relationship
+     *
+     * Example: Post → morphOne(Image, 'imageable')
+     */
+    morphOne(related, morphName, localKey = 'id') {
+        return new Relations_1.MorphOne(related, this, morphName, `${morphName}_type`, `${morphName}_id`, localKey);
+    }
+    /**
+     * Define a polymorphic has-many relationship
+     *
+     * Example: Post → morphMany(Comment, 'commentable')
+     */
+    morphMany(related, morphName, localKey = 'id') {
+        return new Relations_1.MorphMany(related, this, morphName, `${morphName}_type`, `${morphName}_id`, localKey);
+    }
+    /**
+     * Define the inverse of a polymorphic relationship
+     *
+     * Example: Comment → morphTo('commentable')
+     */
+    morphTo(morphName, morphMap = {}) {
+        return new Relations_1.MorphTo(this, morphName, `${morphName}_type`, `${morphName}_id`, morphMap);
+    }
     /**
      * Get a relationship value
      */
@@ -381,13 +689,25 @@ class Model {
         return this;
     }
     /**
-     * Load a relationship
+     * Eagerly load a relationship on this instance
+     */
+    async load(...relationNames) {
+        for (const relation of relationNames) {
+            if (typeof this[relation] === 'function') {
+                const relationInstance = this[relation]();
+                const result = await relationInstance.get();
+                this.setRelation(relation, result);
+            }
+        }
+        return this;
+    }
+    /**
+     * Load relationships only if they haven't been loaded yet
      */
-    async load(relation) {
-        if (typeof this[relation] === 'function') {
-            const relationInstance = this[relation]();
-            const result = await relationInstance.get();
-            this.setRelation(relation, result);
+    async loadMissing(...relationNames) {
+        const toLoad = relationNames.filter(name => !(name in this.relations));
+        if (toLoad.length > 0) {
+            await this.load(...toLoad);
         }
         return this;
     }
@@ -401,6 +721,14 @@ Model.table = '';
  * The primary key for the model
  */
 Model.primaryKey = 'id';
+/**
+ * Indicates if the model should use timestamps
+ */
+Model.timestamps = true;
+/**
+ * Indicates if dates should be serialized to UTC (ISO string) or Local string
+ */
+Model.serializeDateAsUtc = false;
 /**
  * Model query builder wrapper
  */
@@ -437,8 +765,14 @@ class ModelQueryBuilder {
      * Create a new record
      */
     async create(data) {
+        let instance = new this.modelClass();
+        if (instance.usesTimestamps()) {
+            const now = new Date();
+            data['created_at'] = data['created_at'] || now;
+            data['updated_at'] = data['updated_at'] || now;
+        }
         const result = await this.queryBuilder.insert(data);
-        const instance = this.hydrate(data);
+        instance = this.hydrate(data);
         // Set the primary key if it was auto-generated
         const primaryKey = instance['getPrimaryKey']();
         if (result && result.insertId && !data[primaryKey]) {
@@ -448,6 +782,12 @@ class ModelQueryBuilder {
         instance['syncOriginal']();
         return instance;
     }
+    /**
+     * Insert a record or multiple records natively (Bulk Insert)
+     */
+    async insert(data) {
+        return await this.queryBuilder.insert(data);
+    }
     /**
      * Add a where clause
      */
@@ -553,6 +893,13 @@ class ModelQueryBuilder {
     async count(column) {
         return await this.queryBuilder.count(column);
     }
+    /**
+     * Cache the query results
+     */
+    cache(ttl, key) {
+        this.queryBuilder.cache(ttl, key);
+        return this;
+    }
     /**
      * Eager load relationships
      */
@@ -570,6 +917,119 @@ class ModelQueryBuilder {
         }
         return this;
     }
+    /**
+     * Include subqueries to count given relationships
+     */
+    withCount(relations) {
+        const relationNames = Array.isArray(relations) ? relations : [relations];
+        const dummy = new this.modelClass();
+        const outerTable = dummy.getTable();
+        for (const rel of relationNames) {
+            if (typeof dummy[rel] !== 'function') {
+                throw new Error(`Relation ${rel} does not exist on model ${dummy.constructor.name}`);
+            }
+            const relationInstance = dummy[rel]();
+            if (typeof relationInstance.getRelationCountQuery !== 'function') {
+                throw new Error(`Relation ${rel} does not support withCount natively`);
+            }
+            const { sql, bindings } = relationInstance.getRelationCountQuery(outerTable);
+            this.queryBuilder.selectRaw(`${sql} AS ${rel}_count`, bindings);
+        }
+        return this;
+    }
+    /**
+     * Add a basic where clause using a related model (WHERE EXISTS)
+     */
+    whereHas(relation, callback) {
+        const dummy = new this.modelClass();
+        const outerTable = dummy.getTable();
+        if (typeof dummy[relation] !== 'function') {
+            throw new Error(`Relation ${relation} does not exist on model ${dummy.constructor.name}`);
+        }
+        const relationInstance = dummy[relation]();
+        this.queryBuilder.whereExists((q) => {
+            const { sql, bindings } = relationInstance.getRelationCountQuery(outerTable);
+            // Replace SELECT COUNT(*) with SELECT 1 for EXISTS optimization
+            const existsSql = sql.replace(/^\(SELECT COUNT\(\*\)/i, '(SELECT 1');
+            q.selectRaw(existsSql.slice(1, -1), bindings); // remove outer parens because whereExists adds them
+            if (callback) {
+                callback(q);
+            }
+        });
+        return this;
+    }
+    /**
+     * Add a basic where clause for absence of a related model (WHERE NOT EXISTS)
+     */
+    whereDoesntHave(relation, callback) {
+        const dummy = new this.modelClass();
+        const outerTable = dummy.getTable();
+        if (typeof dummy[relation] !== 'function') {
+            throw new Error(`Relation ${relation} does not exist on model ${dummy.constructor.name}`);
+        }
+        const relationInstance = dummy[relation]();
+        this.queryBuilder.whereNotExists((q) => {
+            const { sql, bindings } = relationInstance.getRelationCountQuery(outerTable);
+            const existsSql = sql.replace(/^\(SELECT COUNT\(\*\)/i, '(SELECT 1');
+            q.selectRaw(existsSql.slice(1, -1), bindings);
+            if (callback) {
+                callback(q);
+            }
+        });
+        return this;
+    }
+    /**
+     * Paginate the query results
+     */
+    async paginate(page = 1, perPage = 15, path = '/') {
+        const paginatedResult = await this.queryBuilder.paginate(page, perPage, path);
+        // Map and load relations
+        const models = paginatedResult.data.map(data => this.hydrate(data));
+        const finalModels = await this.loadRelations(models);
+        return {
+            data: finalModels,
+            meta: paginatedResult.meta,
+            links: paginatedResult.links
+        };
+    }
+    /**
+     * Paginate the query results without counting total pages
+     */
+    async simplePaginate(page = 1, perPage = 15, path = '/') {
+        const paginatedResult = await this.queryBuilder.simplePaginate(page, perPage, path);
+        // Map and load relations
+        const models = paginatedResult.data.map(data => this.hydrate(data));
+        const finalModels = await this.loadRelations(models);
+        return {
+            data: finalModels,
+            meta: paginatedResult.meta,
+            links: paginatedResult.links
+        };
+    }
+    /**
+     * Cursor paginate for high performance
+     */
+    async cursorPaginate(cursor = null, perPage = 15, cursorColumn = 'id', path = '/') {
+        const paginatedResult = await this.queryBuilder.cursorPaginate(cursor, perPage, cursorColumn, path);
+        // Map and load relations
+        const models = paginatedResult.data.map(data => this.hydrate(data));
+        const finalModels = await this.loadRelations(models);
+        return {
+            data: finalModels,
+            meta: paginatedResult.meta,
+            links: paginatedResult.links
+        };
+    }
+    /**
+     * Chunk the query results
+     */
+    async chunk(count, callback) {
+        return this.queryBuilder.chunk(count, async (results, page) => {
+            const models = results.map(data => this.hydrate(data));
+            const finalModels = await this.loadRelations(models);
+            return callback(finalModels, page);
+        });
+    }
     /**
      * Hydrate a model instance from data
      */