masterrecord 0.3.26 → 0.3.29

package/context.js

@@ -983,7 +983,15 @@ class context {
         this.__entities.push(validModel);  // Store model object
         const buildMod = tools.createNewInstance(validModel, query, this);
         this.__builderEntities.push(buildMod);  // Store query builder entity
-        this[validModel.__name] = buildMod;  // Attach to context for easy access
+
+        // Use getter to return fresh query instance each time (prevents parameter accumulation)
+        Object.defineProperty(this, validModel.__name, {
+            get: function() {
+                return tools.createNewInstance(validModel, query, this);
+            },
+            configurable: true,
+            enumerable: true
+        });
     }
 
     /**
@@ -1057,14 +1065,34 @@ class context {
      * @param {Array<object>} entities - Entities to insert
      */
     async _processBatchInserts(entities) {
+        // Execute beforeSave hooks
+        for (const entity of entities) {
+            if (typeof entity.beforeSave === 'function') {
+                await entity.beforeSave.call(entity);
+            }
+        }
+
         if (entities.length === 1) {
-            // Single insert - use existing insertManager
+            // Single insert - use existing insertManager (already sets ID)
             const insert = new insertManager(this._SQLEngine, this._isModelValid, this.__entities);
             await insert.init(entities[0]);
         } else {
             // Batch insert - 100x faster for multiple records
             try {
-                await this._SQLEngine.bulkInsert(entities);
+                const results = await this._SQLEngine.bulkInsert(entities);
+
+                // Set auto-increment IDs back on entities
+                for (let i = 0; i < entities.length; i++) {
+                    const entity = entities[i];
+                    const result = results[i];
+
+                    if (result && result.id) {
+                        const primaryKey = tools.getPrimaryKeyObject(entity.__entity);
+                        if (entity.__entity[primaryKey]?.auto === true) {
+                            entity[primaryKey] = result.id;
+                        }
+                    }
+                }
             } catch (error) {
                 console.error('[Context] Bulk insert failed, falling back to individual inserts:', error.message);
                 // Fallback to individual inserts
@@ -1074,6 +1102,13 @@ class context {
                 }
             }
         }
+
+        // Execute afterSave hooks
+        for (const entity of entities) {
+            if (typeof entity.afterSave === 'function') {
+                await entity.afterSave.call(entity);
+            }
+        }
     }
 
     /**
@@ -1083,6 +1118,13 @@ class context {
      * @param {Array<object>} entities - Entities to update
      */
     async _processBatchUpdates(entities) {
+        // Execute beforeSave hooks
+        for (const entity of entities) {
+            if (typeof entity.beforeSave === 'function') {
+                await entity.beforeSave.call(entity);
+            }
+        }
+
         if (entities.length === 1) {
             // Single update - use existing logic
             const currentModel = entities[0];
@@ -1132,6 +1174,13 @@ class context {
                 }
             }
         }
+
+        // Execute afterSave hooks
+        for (const entity of entities) {
+            if (typeof entity.afterSave === 'function') {
+                await entity.afterSave.call(entity);
+            }
+        }
     }
 
     /**
@@ -1141,6 +1190,13 @@ class context {
      * @param {Array<object>} entities - Entities to delete
      */
     async _processBatchDeletes(entities) {
+        // Execute beforeDelete hooks
+        for (const entity of entities) {
+            if (typeof entity.beforeDelete === 'function') {
+                await entity.beforeDelete.call(entity);
+            }
+        }
+
         if (entities.length === 1) {
             // Single delete - use existing deleteManager
             const deleteObject = new deleteManager(this._SQLEngine, this.__entities);
@@ -1174,6 +1230,13 @@ class context {
                 }
             }
         }
+
+        // Execute afterDelete hooks
+        for (const entity of entities) {
+            if (typeof entity.afterDelete === 'function') {
+                await entity.afterDelete.call(entity);
+            }
+        }
     }
 
     /**
@@ -1202,8 +1265,8 @@ class context {
             // Performance: Collect affected tables for cache invalidation (single pass)
             const affectedTables = new Set();
             for (const entity of tracked) {
-                if (entity.__entity && entity.__entity.__name) {
-                    affectedTables.add(entity.__entity.__name);
+                if (entity.__name) {
+                    affectedTables.add(entity.__name);
                 }
             }
 
@@ -1286,6 +1349,136 @@ class context {
         this._queryCache.clear();
     }
 
+    /**
+     * Bulk create multiple entities at once
+     *
+     * Creates multiple entity instances and saves them in a single batch operation.
+     * Much faster than creating entities individually.
+     *
+     * @param {string} entityName - Name of the entity class (e.g., 'User')
+     * @param {Array<Object>} data - Array of objects with entity properties
+     * @returns {Promise<Array<Object>>} Array of created entities with IDs set
+     *
+     * @example
+     * const users = await db.bulkCreate('User', [
+     *   { name: 'Alice', email: 'alice@example.com' },
+     *   { name: 'Bob', email: 'bob@example.com' },
+     *   { name: 'Charlie', email: 'charlie@example.com' }
+     * ]);
+     * console.log(users[0].id); // IDs are automatically set
+     */
+    async bulkCreate(entityName, data) {
+        if (!Array.isArray(data) || data.length === 0) {
+            throw new Error('bulkCreate requires a non-empty array of data');
+        }
+
+        const EntityClass = this[entityName];
+        if (!EntityClass) {
+            throw new Error(`Entity ${entityName} not found in context`);
+        }
+
+        const entities = [];
+        for (const item of data) {
+            const entity = EntityClass.new();
+            // Copy properties from data object to entity
+            for (const key in item) {
+                if (item.hasOwnProperty(key)) {
+                    entity[key] = item[key];
+                }
+            }
+            entities.push(entity);
+        }
+
+        await this.saveChanges();
+        return entities;
+    }
+
+    /**
+     * Bulk update multiple entities at once
+     *
+     * Updates multiple existing entities in a single batch operation.
+     * Entities must already be tracked in the context.
+     *
+     * @param {string} entityName - Name of the entity class (e.g., 'User')
+     * @param {Array<Object>} updates - Array of objects with id and properties to update
+     * @returns {Promise<boolean>} True if updates were successful
+     *
+     * @example
+     * await db.bulkUpdate('User', [
+     *   { id: 1, status: 'active' },
+     *   { id: 2, status: 'active' },
+     *   { id: 3, status: 'inactive' }
+     * ]);
+     */
+    async bulkUpdate(entityName, updates) {
+        if (!Array.isArray(updates) || updates.length === 0) {
+            throw new Error('bulkUpdate requires a non-empty array of updates');
+        }
+
+        const EntityClass = this[entityName];
+        if (!EntityClass) {
+            throw new Error(`Entity ${entityName} not found in context`);
+        }
+
+        // Fetch all entities by ID
+        const ids = updates.map(u => u.id).filter(id => id !== undefined);
+        if (ids.length !== updates.length) {
+            throw new Error('All update objects must have an id property');
+        }
+
+        // Load entities and apply updates
+        for (const update of updates) {
+            const entity = await EntityClass.findById(update.id);
+            if (!entity) {
+                throw new Error(`${entityName} with id ${update.id} not found`);
+            }
+
+            // Apply updates to entity
+            for (const key in update) {
+                if (update.hasOwnProperty(key) && key !== 'id') {
+                    entity[key] = update[key];
+                }
+            }
+        }
+
+        await this.saveChanges();
+        return true;
+    }
+
+    /**
+     * Bulk delete multiple entities at once
+     *
+     * Deletes multiple entities by their IDs in a single batch operation.
+     * Much faster than deleting entities individually.
+     *
+     * @param {string} entityName - Name of the entity class (e.g., 'User')
+     * @param {Array<number|string>} ids - Array of entity IDs to delete
+     * @returns {Promise<boolean>} True if deletions were successful
+     *
+     * @example
+     * await db.bulkDelete('User', [1, 2, 3, 4, 5]);
+     */
+    async bulkDelete(entityName, ids) {
+        if (!Array.isArray(ids) || ids.length === 0) {
+            throw new Error('bulkDelete requires a non-empty array of IDs');
+        }
+
+        const EntityClass = this[entityName];
+        if (!EntityClass) {
+            throw new Error(`Entity ${entityName} not found in context`);
+        }
+
+        // Load entities and mark for deletion
+        for (const id of ids) {
+            const entity = await EntityClass.findById(id);
+            if (entity) {
+                await entity.delete();
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Enable or disable query caching
      *

package/mySQLEngine.js

@@ -93,7 +93,13 @@ class MySQLEngine {
 
             const query = `INSERT INTO \`${first.tableName}\` (${first.columns}) VALUES ${valueGroups.join(', ')}`;
             const result = await this._runWithParams(query, allParams);
-            results.push(result);
+
+            // MySQL returns insertId (first ID) and affectedRows (count)
+            // Generate individual result objects for each entity
+            const firstId = result.insertId;
+            for (let i = 0; i < tableEntities.length; i++) {
+                results.push({ id: firstId + i });
+            }
         }
 
         return results;
@@ -447,6 +453,10 @@ class MySQLEngine {
 
         for (const ent in entity) {
             if (!ent.startsWith("_")) {
+                // Skip lifecycle hooks - they are not database columns
+                if (entity[ent].lifecycle === true) {
+                    continue;
+                }
                 if (!entity[ent].foreignKey) {
                     if (entity[ent].relationshipTable) {
                         if ($that.chechUnsupportedWords(entity[ent].relationshipTable)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.26",
+  "version": "0.3.29",
   "description": "An Object-relational mapping for the Master framework. Master Record connects classes to relational database tables to establish a database with almost zero-configuration ",
   "main": "MasterRecord.js",
   "bin": {

package/postgresEngine.js

@@ -120,7 +120,12 @@ class postgresEngine {
 
             const query = `INSERT INTO "${first.tableName}" (${first.columns}) VALUES ${valueGroups.join(', ')} RETURNING ${primaryKey}`;
             const result = await this._runWithParams(query, allParams);
-            results.push(result.rows);
+
+            // PostgreSQL returns rows with the primary key values
+            // Convert to consistent format: { id: value }
+            for (const row of result.rows) {
+                results.push({ id: row[primaryKey] });
+            }
         }
 
         return results;