masterrecord 0.3.27 → 0.3.30

package/Migrations/migrations.js

@@ -24,7 +24,9 @@ class Migrations{
                         newColumns : [],
                         newTables : [],
                         deletedColumns : [],
-                        updatedColumns : []
+                        updatedColumns : [],
+                        newIndexes : [],
+                        deletedIndexes : []
                     }
                     tables.push(table);
                 });
@@ -38,7 +40,9 @@ class Migrations{
                         newColumns : [],
                         newTables : [],
                         deletedColumns : [],
-                        updatedColumns : []
+                        updatedColumns : [],
+                        newIndexes : [],
+                        deletedIndexes : []
                     }
                     
                     oldSchema.forEach(function (oldItem, index) {
@@ -156,11 +160,101 @@ class Migrations{
     #buildMigrationObject(oldSchema, newSchema){
 
         var tables = this.#organizeSchemaByTables(oldSchema, newSchema);
-        
+
         tables = this.#findNewTables(tables);
         tables = this.#findNewColumns(tables);
         tables = this.#findDeletedColumns(tables);
         tables = this.#findUpdatedColumns(tables);
+        tables = this.#findNewIndexes(tables);
+        tables = this.#findDeletedIndexes(tables);
+        return tables;
+    }
+
+    #findNewIndexes(tables){
+        tables.forEach(function (item, index) {
+            if(item.new && item.old){
+                Object.keys(item.new).forEach(function (key) {
+                    if(typeof item.new[key] === "object" && item.new[key].indexes){
+                        var columnName = item.new[key].name;
+                        var newIndexes = item.new[key].indexes;
+
+                        // Check if this column existed before
+                        var oldColumn = null;
+                        Object.keys(item.old).forEach(function (oldKey) {
+                            if(typeof item.old[oldKey] === "object" && item.old[oldKey].name === columnName){
+                                oldColumn = item.old[oldKey];
+                            }
+                        });
+
+                        // If column didn't exist before, or didn't have indexes, all indexes are new
+                        if(!oldColumn || !oldColumn.indexes){
+                            newIndexes.forEach(function(indexName){
+                                item.newIndexes.push({
+                                    tableName: item.name,
+                                    columnName: columnName,
+                                    indexName: indexName
+                                });
+                            });
+                        } else {
+                            // Check for new indexes that weren't in the old column
+                            newIndexes.forEach(function(indexName){
+                                if(!oldColumn.indexes.includes(indexName)){
+                                    item.newIndexes.push({
+                                        tableName: item.name,
+                                        columnName: columnName,
+                                        indexName: indexName
+                                    });
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        });
+        return tables;
+    }
+
+    #findDeletedIndexes(tables){
+        tables.forEach(function (item, index) {
+            if(item.new && item.old){
+                Object.keys(item.old).forEach(function (key) {
+                    if(typeof item.old[key] === "object" && item.old[key].indexes){
+                        var columnName = item.old[key].name;
+                        var oldIndexes = item.old[key].indexes;
+
+                        // Check if this column still exists
+                        var newColumn = null;
+                        Object.keys(item.new).forEach(function (newKey) {
+                            if(typeof item.new[newKey] === "object" && item.new[newKey].name === columnName){
+                                newColumn = item.new[newKey];
+                            }
+                        });
+
+                        // If column doesn't exist anymore, or doesn't have indexes, all indexes are deleted
+                        if(!newColumn || !newColumn.indexes){
+                            oldIndexes.forEach(function(indexName){
+                                item.deletedIndexes.push({
+                                    tableName: item.name,
+                                    columnName: columnName,
+                                    indexName: indexName
+                                });
+                            });
+                        } else {
+                            // Check for indexes that were removed
+                            oldIndexes.forEach(function(indexName){
+                                if(!newColumn.indexes.includes(indexName)){
+                                    item.deletedIndexes.push({
+                                        tableName: item.name,
+                                        columnName: columnName,
+                                        indexName: indexName
+                                    });
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        });
         return tables;
     }
 
@@ -302,6 +396,8 @@ class Migrations{
                (t.newColumns && t.newColumns.length) ||
                (t.deletedColumns && t.deletedColumns.length) ||
                (t.updatedColumns && t.updatedColumns.length) ||
+               (t.newIndexes && t.newIndexes.length) ||
+               (t.deletedIndexes && t.deletedIndexes.length) ||
                (t.old === null) || (t.new === null)){
                 return true;
             }
@@ -348,6 +444,14 @@ class Migrations{
                 }
             });
 
+            item.newIndexes.forEach(function (indexInfo, index) {
+                MT.createIndex("up", indexInfo);
+            });
+
+            item.deletedIndexes.forEach(function (indexInfo, index) {
+                MT.dropIndex("up", indexInfo);
+            });
+
         });
 
        return MT.get();

package/Migrations/schema.js

@@ -110,6 +110,22 @@ class schema{
                     var query = queryBuilder.createTable(table);
                     this.context._execute(query);
                 }
+
+                // Create indexes for columns that have .index() defined
+                const self = this;
+                Object.keys(table).forEach(function(key){
+                    if(typeof table[key] === "object" && table[key].indexes && !key.startsWith('__')){
+                        const columnName = table[key].name;
+                        table[key].indexes.forEach(function(indexName){
+                            const indexInfo = {
+                                tableName: tableName,
+                                columnName: columnName,
+                                indexName: indexName
+                            };
+                            self.createIndex(indexInfo);
+                        });
+                    }
+                });
             }
         }else{
             console.log("Table that you're trying to create is undefined. Please check if there are any changes that need to be made");
@@ -394,6 +410,56 @@ class schema{
         }
     }
 
+    createIndex(indexInfo){
+        if(indexInfo){
+            if(this.context.isSQLite){
+                var sqliteQuery = require("./migrationSQLiteQuery");
+                var queryBuilder = new sqliteQuery();
+                var query = queryBuilder.createIndex(indexInfo);
+                this.context._execute(query);
+            }
+
+            if(this.context.isMySQL){
+                var sqlquery = require("./migrationMySQLQuery");
+                var queryBuilder = new sqlquery();
+                var query = queryBuilder.createIndex(indexInfo);
+                this.context._execute(query);
+            }
+
+            if(this.context.isPostgres){
+                var postgresQuery = require("./migrationPostgresQuery");
+                var queryBuilder = new postgresQuery();
+                var query = queryBuilder.createIndex(indexInfo);
+                this.context._execute(query);
+            }
+        }
+    }
+
+    dropIndex(indexInfo){
+        if(indexInfo){
+            if(this.context.isSQLite){
+                var sqliteQuery = require("./migrationSQLiteQuery");
+                var queryBuilder = new sqliteQuery();
+                var query = queryBuilder.dropIndex(indexInfo);
+                this.context._execute(query);
+            }
+
+            if(this.context.isMySQL){
+                var sqlquery = require("./migrationMySQLQuery");
+                var queryBuilder = new sqlquery();
+                var query = queryBuilder.dropIndex(indexInfo);
+                this.context._execute(query);
+            }
+
+            if(this.context.isPostgres){
+                var postgresQuery = require("./migrationPostgresQuery");
+                var queryBuilder = new postgresQuery();
+                var query = queryBuilder.dropIndex(indexInfo);
+                this.context._execute(query);
+            }
+        }
+    }
+
     seed(tableName, rows){
         if(!tableName || !rows){ return; }
         const items = Array.isArray(rows) ? rows : [rows];

package/QueryLanguage/queryMethods.js

@@ -196,6 +196,76 @@ class queryMethods{
         }
     }
 
+    /**
+     * Get first record ordered by primary key
+     */
+    async first() {
+        // Find primary key
+        let primaryKey = null;
+        for (const fieldName in this.__entity) {
+            if (this.__entity[fieldName]?.primary === true) {
+                primaryKey = fieldName;
+                break;
+            }
+        }
+
+        if (primaryKey && !this.__queryObject.script.orderBy) {
+            // Use proper orderBy syntax with lambda expression
+            const orderByExpr = `e => e.${primaryKey}`;
+            this.orderBy(orderByExpr);
+        }
+
+        this.__queryObject.script.take = 1;
+        return await this.single();
+    }
+
+    /**
+     * Get last record ordered by primary key descending
+     */
+    async last() {
+        let primaryKey = null;
+        for (const fieldName in this.__entity) {
+            if (this.__entity[fieldName]?.primary === true) {
+                primaryKey = fieldName;
+                break;
+            }
+        }
+
+        if (primaryKey && !this.__queryObject.script.orderBy) {
+            // Use proper orderByDescending syntax with lambda expression
+            const orderByExpr = `e => e.${primaryKey}`;
+            this.orderByDescending(orderByExpr);
+        }
+
+        this.__queryObject.script.take = 1;
+        return await this.single();
+    }
+
+    /**
+     * Check if any records match the query
+     */
+    async exists() {
+        this.__queryObject.script.take = 1;
+        const result = await this.single();
+        return result !== null;
+    }
+
+    /**
+     * Extract single column values as array
+     */
+    async pluck(fieldName) {
+        if (!fieldName || typeof fieldName !== 'string') {
+            throw new Error('pluck() requires a field name string');
+        }
+
+        if (!this.__entity[fieldName]) {
+            throw new Error(`Field '${fieldName}' does not exist on ${this.__entity.__name}`);
+        }
+
+        const entities = await this.toList();
+        return entities.map(entity => entity[fieldName]);
+    }
+
     /**
      * Transform .includes() syntax to .any() syntax
      * Converts: $$.includes(entity.field) => entity.field.any($$)
@@ -282,9 +352,10 @@ class queryMethods{
 
                     // Add array parameters and get comma-separated placeholders
                     const placeholders = this.__queryObject.parameters.addParams(itemArray, dbType);
-                    // Replace $$ first (preferred), then $ (backwards compatibility)
+                    // Replace ONLY FIRST $$ occurrence (not all with /g flag)
+                    // This ensures each parameter gets replaced in order
                     if(str.includes('$$')){
-                        str = str.replace(/\$\$/g, placeholders);
+                        str = str.replace(/\$\$/, placeholders);  // ✅ No 'g' flag - replace first only
                     } else {
                         // Replace single $ but not $N (postgres placeholders)
                         str = str.replace(/\$(?!\d)/, placeholders);
@@ -303,9 +374,10 @@ class queryMethods{
 
                     // Add parameter and replace placeholder
                     const placeholder = this.__queryObject.parameters.addParam(item, dbType);
-                    // Replace $$ first (preferred), then $ (backwards compatibility)
+                    // Replace ONLY FIRST $$ occurrence (not all with /g flag)
+                    // This ensures each parameter gets replaced in order
                     if(str.includes('$$')){
-                        str = str.replace(/\$\$/g, placeholder);
+                        str = str.replace(/\$\$/, placeholder);  // ✅ No 'g' flag - replace first only
                     } else {
                         // Replace single $ but not $N (postgres placeholders)
                         str = str.replace(/\$(?!\d)/, placeholder);
@@ -358,6 +430,7 @@ class queryMethods{
             const cached = this.__context._queryCache.get(cacheKey);
             if (cached) {
                 this.__reset();
+                // Cached entities already have methods - return directly
                 return cached;
             }
         }
@@ -407,6 +480,7 @@ class queryMethods{
             const cached = this.__context._queryCache.get(cacheKey);
             if (cached) {
                 this.__reset();
+                // Cached entities already have methods - return array directly
                 return cached;
             }
         }
@@ -465,6 +539,66 @@ class queryMethods{
                             enumerable: true,
                             configurable: true,
                             set: function(value) {
+                                // Run validators before setting value
+                                if (fieldDef && fieldDef.validators && Array.isArray(fieldDef.validators)) {
+                                    for (const validator of fieldDef.validators) {
+                                        let isValid = true;
+                                        let errorMsg = validator.message;
+
+                                        switch (validator.type) {
+                                            case 'required':
+                                                isValid = value !== null && value !== undefined && value !== '';
+                                                break;
+
+                                            case 'email':
+                                                if (value) {
+                                                    isValid = validator.pattern.test(value);
+                                                }
+                                                break;
+
+                                            case 'minLength':
+                                                if (value && typeof value === 'string') {
+                                                    isValid = value.length >= validator.length;
+                                                }
+                                                break;
+
+                                            case 'maxLength':
+                                                if (value && typeof value === 'string') {
+                                                    isValid = value.length <= validator.length;
+                                                }
+                                                break;
+
+                                            case 'pattern':
+                                                if (value) {
+                                                    isValid = validator.pattern.test(value);
+                                                }
+                                                break;
+
+                                            case 'min':
+                                                if (value !== null && value !== undefined) {
+                                                    isValid = Number(value) >= validator.min;
+                                                }
+                                                break;
+
+                                            case 'max':
+                                                if (value !== null && value !== undefined) {
+                                                    isValid = Number(value) <= validator.max;
+                                                }
+                                                break;
+
+                                            case 'custom':
+                                                if (typeof validator.validator === 'function') {
+                                                    isValid = validator.validator(value);
+                                                }
+                                                break;
+                                        }
+
+                                        if (!isValid) {
+                                            throw new Error(`Validation failed: ${errorMsg}`);
+                                        }
+                                    }
+                                }
+
                                 this.__proto__["_" + fname] = value;
                                 if(!this.__dirtyFields.includes(fname)){
                                     this.__dirtyFields.push(fname);
@@ -498,8 +632,200 @@ class queryMethods{
             return await this.__context.saveChanges();
         };
 
+        // Convert entity to plain JavaScript object
+        newEntity.toObject = function(options = {}) {
+            const includeRelationships = options.includeRelationships !== false;
+            const depth = options.depth || 1;
+            const visited = options._visited || new WeakSet();
+
+            // Prevent circular reference infinite loops
+            if (visited.has(this)) {
+                return { __circular: true, __entityName: this.__name, id: this[this.__primaryKey] };
+            }
+            visited.add(this);
+
+            const plain = {};
+
+            // Iterate through entity definition
+            for (const fieldName in this.__entity) {
+                if (fieldName.startsWith('__')) continue;
+
+                const fieldDef = this.__entity[fieldName];
+                const isRelationship = fieldDef?.type === 'hasMany' ||
+                                       fieldDef?.type === 'hasOne' ||
+                                       fieldDef?.relationshipType === 'belongsTo';
+
+                // Skip relationships in this pass
+                if (!isRelationship) {
+                    try {
+                        plain[fieldName] = this[fieldName];
+                    } catch (e) {
+                        // Skip fields that throw errors when accessed
+                    }
+                }
+            }
+
+            // Handle relationships recursively with depth limit and cycle detection
+            if (includeRelationships && depth > 0) {
+                for (const fieldName in this.__entity) {
+                    const fieldDef = this.__entity[fieldName];
+                    const isRelationship = fieldDef?.type === 'hasMany' ||
+                                           fieldDef?.type === 'hasOne' ||
+                                           fieldDef?.relationshipType === 'belongsTo';
+
+                    if (isRelationship) {
+                        try {
+                            const value = this[fieldName];
+
+                            if (Array.isArray(value)) {
+                                plain[fieldName] = value.map(item => {
+                                    if (item?.toObject && typeof item.toObject === 'function') {
+                                        return item.toObject({
+                                            depth: depth - 1,
+                                            _visited: visited
+                                        });
+                                    }
+                                    return item;
+                                });
+                            } else if (value?.toObject && typeof value.toObject === 'function') {
+                                plain[fieldName] = value.toObject({
+                                    depth: depth - 1,
+                                    _visited: visited
+                                });
+                            }
+                        } catch (e) {
+                            // Skip relationships that throw errors when accessed
+                        }
+                    }
+                }
+            }
+
+            return plain;
+        };
+
+        // JSON.stringify compatibility
+        newEntity.toJSON = function() {
+            return this.toObject({ includeRelationships: false });
+        };
+
+        // Delete entity from database
+        newEntity.delete = async function() {
+            if (!this.__context) {
+                throw new Error('Cannot delete: entity is not attached to a context');
+            }
+
+            // Mark entity for deletion
+            this.__state = 'delete';
+
+            // Ensure entity is tracked
+            if (!this.__context.__trackedEntitiesMap.has(this.__ID)) {
+                this.__context.__track(this);
+            }
+
+            // Execute delete via saveChanges
+            return await this.__context.saveChanges();
+        };
+
+        // Reload entity from database
+        newEntity.reload = async function() {
+            if (!this.__context) {
+                throw new Error('Cannot reload: entity is not attached to a context');
+            }
+
+            // Get primary key
+            let primaryKey = null;
+            for (const fieldName in this.__entity) {
+                if (this.__entity[fieldName]?.primary === true) {
+                    primaryKey = fieldName;
+                    break;
+                }
+            }
+
+            const primaryKeyValue = this[primaryKey];
+
+            if (!primaryKeyValue) {
+                throw new Error('Cannot reload: entity has no primary key value');
+            }
+
+            // Fetch fresh from database
+            const EntityClass = this.__context[this.__name];
+            const fresh = await EntityClass.findById(primaryKeyValue);
+            if (!fresh) {
+                throw new Error(
+                    `Cannot reload: ${this.__name} with ${primaryKey}=${primaryKeyValue} not found`
+                );
+            }
+
+            // Copy all field values from fresh entity to this entity
+            for (const fieldName in this.__entity) {
+                if (fieldName.startsWith('__')) continue;
+
+                const fieldDef = this.__entity[fieldName];
+                const isRelationship = fieldDef?.type === 'hasMany' ||
+                                       fieldDef?.type === 'hasOne' ||
+                                       fieldDef?.relationshipType === 'belongsTo';
+
+                // Only reload scalar fields
+                if (!isRelationship) {
+                    this.__proto__["_" + fieldName] = fresh.__proto__["_" + fieldName];
+                }
+            }
+
+            // Reset dirty fields and state
+            this.__dirtyFields = [];
+            this.__state = 'track';
+
+            return this;
+        };
+
+        // Clone entity for duplication
+        newEntity.clone = function() {
+            if (!this.__context) {
+                throw new Error('Cannot clone: entity is not attached to a context');
+            }
+
+            const EntityClass = this.__context[this.__name];
+            const cloned = EntityClass.new();
+
+            // Get primary key (to skip it)
+            let primaryKey = null;
+            for (const fieldName in this.__entity) {
+                if (this.__entity[fieldName]?.primary === true) {
+                    primaryKey = fieldName;
+                    break;
+                }
+            }
+
+            // Copy all non-primary key fields
+            for (const fieldName in this.__entity) {
+                if (fieldName.startsWith('__')) continue;
+                if (fieldName === primaryKey) continue;
+
+                const fieldDef = this.__entity[fieldName];
+                const isRelationship = fieldDef?.type === 'hasMany' ||
+                                       fieldDef?.type === 'hasOne' ||
+                                       fieldDef?.relationshipType === 'belongsTo';
+
+                if (!isRelationship) {
+                    cloned[fieldName] = this[fieldName];
+                }
+            }
+
+            return cloned;
+        };
+
         // Track the entity
         this.__context.__track(newEntity);
+
+        // Copy lifecycle hooks from entity definition to entity instance
+        for (const fieldName in this.__entity) {
+            const fieldDef = this.__entity[fieldName];
+            if (fieldDef && fieldDef.lifecycle === true && fieldDef.method) {
+                // Bind the lifecycle hook method directly to this entity instance
+                newEntity[fieldName] = fieldDef.method.bind(newEntity);
+            }
+        }
+
         return newEntity;
     }
 

package/SQLLiteEngine.js

@@ -583,6 +583,10 @@ class SQLLiteEngine {
     var $that = this;
     for (var 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/Tools.js

@@ -84,7 +84,7 @@ class Tools{
     }
 
     static clearAllProto(proto){
-       
+
         var newproto = {}
         if(proto.__proto__ ){
             // Include non-enumerable own properties so we don't lose values defined via getters
@@ -93,6 +93,15 @@ class Tools{
                 if(!key.startsWith("_") && !key.startsWith("__")){
                     try{
                         const value = proto[key];
+                        // Skip lifecycle hooks by checking entity definition
+                        if(proto.__entity && proto.__entity[key] && proto.__entity[key].lifecycle === true){
+                            continue;
+                        }
+                        // Skip functions EXCEPT if they're defined via getters (typeof returns value, not function)
+                        // Only skip if it's actually a function value (methods like save, delete, toObject)
+                        if(typeof value === "function"){
+                            continue;
+                        }
                         if(typeof value === "object" && value !== null){
                             // Recursively clone nested objects without altering the source
                             newproto[key] = this.clearAllProto(value);
@@ -180,10 +189,14 @@ class Tools{
     // converts any object into SQL parameter select string
 
     static convertEntityToSelectParameterString(obj){
-        // todo: loop throgh object and append string with comma to 
+        // todo: loop throgh object and append string with comma to
         var mainString = "";
         const entries = Object.keys(obj);
         for (const key of entries) {
+            // Skip lifecycle hooks - they are not database columns
+            if(obj[key].lifecycle === true){
+                continue;
+            }
             if(obj[key].type !== 'hasManyThrough' && obj[key].type !== "hasMany" && obj[key].type !== "hasOne"){
                 if(obj[key].name){
                     mainString = mainString === "" ?  `${obj.__name}.${obj[key].name}` : `${mainString}, ${obj.__name}.${obj[key].name}`;