masterrecord 0.2.36 → 0.3.1

package/Migrations/schema.js

@@ -38,6 +38,14 @@ class schema{
                 var query = queryBuilder.addColum(table);
                 this.context._execute(query);
             }
+
+            if(this.context.isPostgres){
+                var postgresQuery = require("./migrationPostgresQuery");
+                var queryBuilder = new postgresQuery();
+                table.realDataType = queryBuilder.typeManager(table.type);
+                var query = queryBuilder.addColum(table);
+                this.context._execute(query);
+            }
         }
 
         // add column to database
@@ -46,7 +54,7 @@ class schema{
     dropColumn(table){
         if(table){
             if(this.fullTable){
-                // drop column 
+                // drop column
                 if(this.context.isSQLite){
                     var sqliteQuery = require("./migrationSQLiteQuery");
                     var queryBuilder = new sqliteQuery();
@@ -61,6 +69,13 @@ class schema{
                     this.context._execute(query);
                 }
 
+                if(this.context.isPostgres){
+                    var postgresQuery = require("./migrationPostgresQuery");
+                    var queryBuilder = new postgresQuery();
+                    var query = queryBuilder.dropColumn(table);
+                    this.context._execute(query);
+                }
+
             }else{
                 console.log("Must call the addTable function.");
             }
@@ -88,6 +103,13 @@ class schema{
                     var query = queryBuilder.createTable(table);
                     this.context._execute(query);
                 }
+
+                if(this.context.isPostgres){
+                    var postgresQuery = require("./migrationPostgresQuery");
+                    var queryBuilder = new postgresQuery();
+                    var query = queryBuilder.createTable(table);
+                    this.context._execute(query);
+                }
             }
         }else{
             console.log("Table that you're trying to create is undefined. Please check if there are any changes that need to be made");
@@ -130,6 +152,13 @@ class schema{
                         const query = queryBuilder.addColum(newCol);
                         this.context._execute(query);
                     }
+                    if(this.context.isPostgres){
+                        var postgresQuery = require("./migrationPostgresQuery");
+                        var queryBuilder = new postgresQuery();
+                        newCol.realDataType = queryBuilder.typeManager(col.type);
+                        const query = queryBuilder.addColum(newCol);
+                        this.context._execute(query);
+                    }
                 }
             }
         }
@@ -255,6 +284,13 @@ class schema{
                 var query = queryBuilder.dropTable(table.__name);
                 this.context._execute(query);
             }
+
+            if(this.context.isPostgres){
+                var postgresQuery = require("./migrationPostgresQuery");
+                var queryBuilder = new postgresQuery();
+                var query = queryBuilder.dropTable(table.__name);
+                this.context._execute(query);
+            }
         }
     }
 
@@ -272,10 +308,16 @@ class schema{
             const admin = new MySQLClient(baseConfig);
             admin.connect();
             if(!admin.connection){ return; }
-            const check = admin.query(`SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '${dbName}'`);
+
+            // Use parameterized query for checking database existence
+            const check = admin.query(`SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?`, [dbName]);
             const exists = Array.isArray(check) ? check.length > 0 : !!check?.length;
             if(!exists){
-                // Create with sensible defaults
+                // Validate database name (alphanumeric, underscore, hyphen only)
+                if(!/^[a-zA-Z0-9_-]+$/.test(dbName)){
+                    throw new Error(`Invalid database name: ${dbName}. Only alphanumeric characters, underscores, and hyphens are allowed.`);
+                }
+                // CREATE DATABASE doesn't support placeholders, but we've validated the name
                 admin.query(`CREATE DATABASE \`${dbName}\` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
             }
             admin.close();
@@ -313,6 +355,13 @@ class schema{
                     this.context._execute(query);
                 }
 
+                if(this.context.isPostgres){
+                    var postgresQuery = require("./migrationPostgresQuery");
+                    var queryBuilder = new postgresQuery();
+                    var query = queryBuilder.alterColumn(table);
+                    this.context._execute(query);
+                }
+
             }else{
                 console.log("Must call the addTable function.");
             }
@@ -334,38 +383,92 @@ class schema{
                 var query = queryBuilder.renameColumn(table);
                 this.context._execute(query);
             }
+
+            if(this.context.isPostgres){
+                var postgresQuery = require("./migrationPostgresQuery");
+                var queryBuilder = new postgresQuery();
+                var query = queryBuilder.renameColumn(table);
+                this.context._execute(query);
+            }
         }
     }
 
     seed(tableName, rows){
         if(!tableName || !rows){ return; }
         const items = Array.isArray(rows) ? rows : [rows];
-        for(const row of items){
-            const cols = Object.keys(row);
-            if(cols.length === 0){ continue; }
-            const colList = cols.map(c => this.context.isSQLite ? `[${c}]` : `${c}`).join(", ");
-            const vals = cols.map(k => {
-                const v = row[k];
-                if(v === null || v === undefined){ return 'NULL'; }
-                if(typeof v === 'boolean'){
-                    return this.context.isSQLite ? (v ? 1 : 0) : (v ? 1 : 0);
-                }
-                if(typeof v === 'number'){
-                    return String(v);
-                }
-                const esc = String(v).replace(/'/g, "''");
-                return `'${esc}'`;
-            }).join(", ");
-            // Idempotent seed: ignore duplicates on unique indexes
-            let sql;
-            if(this.context.isSQLite){
-                sql = `INSERT OR IGNORE INTO ${tableName} (${colList}) VALUES (${vals})`;
-            } else if(this.context.isMySQL){
-                sql = `INSERT IGNORE INTO ${tableName} (${colList}) VALUES (${vals})`;
-            } else {
-                sql = `INSERT INTO ${tableName} (${colList}) VALUES (${vals})`;
+
+        // Use query builders for consistent seed data handling
+        if(this.context.isSQLite){
+            var sqliteQuery = require("./migrationSQLiteQuery");
+            var queryBuilder = new sqliteQuery();
+            for(const row of items){
+                // SQLite: Use INSERT OR IGNORE for idempotency
+                const query = queryBuilder.insertSeedData(tableName, row);
+                const idempotentQuery = query.replace(/^INSERT INTO/, 'INSERT OR IGNORE INTO');
+                this.context._execute(idempotentQuery);
+            }
+        }
+
+        if(this.context.isMySQL){
+            var sqlquery = require("./migrationMySQLQuery");
+            var queryBuilder = new sqlquery();
+            for(const row of items){
+                // MySQL: Use INSERT IGNORE for idempotency
+                const query = queryBuilder.insertSeedData(tableName, row);
+                const idempotentQuery = query.replace(/^INSERT INTO/, 'INSERT IGNORE INTO');
+                this.context._execute(idempotentQuery);
+            }
+        }
+
+        if(this.context.isPostgres){
+            var postgresQuery = require("./migrationPostgresQuery");
+            var queryBuilder = new postgresQuery();
+            for(const row of items){
+                // PostgreSQL: Use INSERT ... ON CONFLICT DO NOTHING for idempotency
+                // Note: This requires a unique constraint or primary key
+                const query = queryBuilder.insertSeedData(tableName, row);
+                const idempotentQuery = query + ' ON CONFLICT DO NOTHING';
+                this.context._execute(idempotentQuery);
+            }
+        }
+    }
+
+    /**
+     * Bulk seed data insertion (more efficient for multiple rows)
+     * @param {string} tableName - Name of the table
+     * @param {Array} rows - Array of data objects
+     */
+    bulkSeed(tableName, rows){
+        if(!tableName || !rows || rows.length === 0){ return; }
+
+        if(this.context.isSQLite){
+            var sqliteQuery = require("./migrationSQLiteQuery");
+            var queryBuilder = new sqliteQuery();
+            const query = queryBuilder.bulkInsertSeedData(tableName, rows);
+            if(query){
+                const idempotentQuery = query.replace(/^INSERT INTO/, 'INSERT OR IGNORE INTO');
+                this.context._execute(idempotentQuery);
+            }
+        }
+
+        if(this.context.isMySQL){
+            var sqlquery = require("./migrationMySQLQuery");
+            var queryBuilder = new sqlquery();
+            const query = queryBuilder.bulkInsertSeedData(tableName, rows);
+            if(query){
+                const idempotentQuery = query.replace(/^INSERT INTO/, 'INSERT IGNORE INTO');
+                this.context._execute(idempotentQuery);
+            }
+        }
+
+        if(this.context.isPostgres){
+            var postgresQuery = require("./migrationPostgresQuery");
+            var queryBuilder = new postgresQuery();
+            const query = queryBuilder.bulkInsertSeedData(tableName, rows);
+            if(query){
+                const idempotentQuery = query + ' ON CONFLICT DO NOTHING';
+                this.context._execute(idempotentQuery);
             }
-            this.context._execute(sql);
         }
     }
     

package/QueryLanguage/queryMethods.js

@@ -61,28 +61,28 @@ class queryMethods{
 
     ______orderByCount(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'orderByCount');
+        str = this.__validateAndCollectParameters(str, args, 'orderByCount');
         this.__queryObject.orderByCount(str, this.__entity.__name);
         return this;
     }
 
     ______orderByCountDescending(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'orderByCountDescending');
+        str = this.__validateAndCollectParameters(str, args, 'orderByCountDescending');
         this.__queryObject.orderByCountDesc(str, this.__entity.__name);
         return this;
     }
 
     orderBy(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'orderBy');
+        str = this.__validateAndCollectParameters(str, args, 'orderBy');
         this.__queryObject.orderBy(str, this.__entity.__name);
         return this;
     }
 
     orderByDescending(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'orderByDescending');
+        str = this.__validateAndCollectParameters(str, args, 'orderByDescending');
         this.__queryObject.orderByDesc(str, this.__entity.__name);
         return this;
     }
@@ -95,14 +95,22 @@ class queryMethods{
     /* WHERE and AND work together its a way to add to the WHERE CLAUSE DYNAMICALLY */
     and(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'and');
+        // Transform .includes() syntax to .any() syntax
+        var transformResult = this.__transformIncludes(str, args);
+        str = transformResult.query;
+        args = transformResult.args;
+        str = this.__validateAndCollectParameters(str, args, 'and');
         this.__queryObject.and(str, this.__entity.__name);
         return this;
     }
 
     where(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'where');
+        // Transform .includes() syntax to .any() syntax
+        var transformResult = this.__transformIncludes(str, args);
+        str = transformResult.query;
+        args = transformResult.args;
+        str = this.__validateAndCollectParameters(str, args, 'where');
         this.__queryObject.where(str, this.__entity.__name);
         return this;
     }
@@ -111,7 +119,7 @@ class queryMethods{
     //Eagerly loading
     include(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'include');
+        str = this.__validateAndCollectParameters(str, args, 'include');
         this.__queryObject.include(str, this.__entity.__name);
         return this;
     }
@@ -119,7 +127,7 @@ class queryMethods{
     // only takes a array of selected items
     select(query,  ...args){
         var str = query.toString();
-        str = this.__validateAndReplacePlaceholders(str, args, 'select');
+        str = this.__validateAndCollectParameters(str, args, 'select');
         this.__queryObject.select(str, this.__entity.__name);
         return this;
     }
@@ -141,7 +149,7 @@ class queryMethods{
     count(query,  ...args){
         if(query){
             var str = query.toString();
-            str = this.__validateAndReplacePlaceholders(str, args, 'count');
+            str = this.__validateAndCollectParameters(str, args, 'count');
             this.__queryObject.count(str, this.__entity.__name);
         }
 
@@ -152,7 +160,7 @@ class queryMethods{
             this.__reset();
             return val;
         }
-        
+
         if(this.__context.isMySQL){
             // trying to match string select and relace with select Count(*);
             var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
@@ -162,15 +170,58 @@ class queryMethods{
         }
     }
 
-    __validateAndReplacePlaceholders(str, args, methodName){
-        // Count placeholders
-        const placeholderCount = (str.match(/\$\$/g) || []).length;
+    /**
+     * Transform .includes() syntax to .any() syntax
+     * Converts: $$.includes(entity.field) => entity.field.any($$)
+     * This allows natural JavaScript array syntax while using existing .any() infrastructure
+     */
+    __transformIncludes(str, args){
+        // Pattern: $$.includes(entity.field) or $$.includes(entity.field.nested)
+        const includesPattern = /\$\$\.includes\s*\(\s*([\w\d$_]+)\.([.\w\d_]+)\s*\)/g;
+
+        // Use replace with a function - when using a function, return value is used literally
+        const transformedStr = str.replace(includesPattern, (match, entity, field) => {
+            // Transform to .any() syntax: entity.field.any($$)
+            return entity + '.' + field + '.any($$)';
+        });
+
+        return { query: transformedStr, args: args };
+    }
+
+    __validateAndCollectParameters(str, args, methodName){
+        // Count placeholders - support both $$ (standard) and $ (backwards compatibility)
+        // Match $$ first to avoid double-counting, then match remaining single $
+        let placeholderCount = 0;
+        let tempStr = str;
+
+        // Count $$ placeholders first
+        const doubleDollarMatches = tempStr.match(/\$\$/g);
+        if(doubleDollarMatches){
+            placeholderCount += doubleDollarMatches.length;
+            // Remove $$ from string to avoid double-counting
+            tempStr = tempStr.replace(/\$\$/g, '');
+        }
+
+        // Count remaining single $ placeholders
+        // Exclude $N (postgres placeholders like $1, $2) and $$ (already counted)
+        const singleDollarMatches = tempStr.match(/\$(?!\d)/g);
+        if(singleDollarMatches){
+            placeholderCount += singleDollarMatches.length;
+        }
+
         const providedCount = args ? args.length : 0;
         if(placeholderCount !== providedCount){
-            const msg = `Query argument error in ${methodName}: expected ${placeholderCount} value(s) for '$$', but received ${providedCount}.`;
+            const msg = `Query argument error in ${methodName}: expected ${placeholderCount} value(s) for parameter placeholders, but received ${providedCount}. Use $$ or $ for parameters.`;
             console.error(msg);
             throw new Error(msg);
         }
+
+        // Get database type from context
+        const dbType = this.__context.isSQLite ? 'sqlite' :
+                      this.__context.isMySQL ? 'mysql' :
+                      this.__context.isPostgres ? 'postgres' : 'sqlite';
+
+        // Replace $$ with ? placeholders and collect parameter values
         if(args){
             for(let argument in args){
                 var item = args[argument];
@@ -179,12 +230,90 @@ class queryMethods{
                     console.error(msg);
                     throw new Error(msg);
                 }
-                str = str.replace("$$", item);
+
+                // Check if this is an array (for IN clauses / .includes() / .any())
+                let itemArray = null;
+                if(Array.isArray(item)){
+                    itemArray = item;
+                }
+                // Also handle comma-separated strings for .any() method
+                else if(typeof item === 'string' && item.includes(',')){
+                    // Split comma-separated string into array
+                    itemArray = item.split(',').map(v => v.trim());
+                }
+
+                if(itemArray){
+                    // Validate each array element
+                    try {
+                        for(const val of itemArray){
+                            this.__queryObject.parameters.validateValue(val);
+                        }
+                    } catch(err) {
+                        const msg = `Query argument error in ${methodName}: ${err.message}`;
+                        console.error(msg);
+                        throw new Error(msg);
+                    }
+
+                    // Add array parameters and get comma-separated placeholders
+                    const placeholders = this.__queryObject.parameters.addParams(itemArray, dbType);
+                    // Replace $$ first (preferred), then $ (backwards compatibility)
+                    if(str.includes('$$')){
+                        str = str.replace("$$", placeholders);
+                    } else {
+                        // Replace single $ but not $N (postgres placeholders)
+                        str = str.replace(/\$(?!\d)/, placeholders);
+                    }
+                }
+                else{
+                    // Single value - existing logic
+                    // Validate parameter value is safe
+                    try {
+                        this.__queryObject.parameters.validateValue(item);
+                    } catch(err) {
+                        const msg = `Query argument error in ${methodName}: ${err.message}`;
+                        console.error(msg);
+                        throw new Error(msg);
+                    }
+
+                    // Add parameter and replace placeholder
+                    const placeholder = this.__queryObject.parameters.addParam(item, dbType);
+                    // Replace $$ first (preferred), then $ (backwards compatibility)
+                    if(str.includes('$$')){
+                        str = str.replace("$$", placeholder);
+                    } else {
+                        // Replace single $ but not $N (postgres placeholders)
+                        str = str.replace(/\$(?!\d)/, placeholder);
+                    }
+                }
             }
         }
         return str;
     }
 
+    // Convenience method: Find record by primary key ID
+    findById(id){
+        // Find the primary key field in the entity
+        let primaryKeyField = null;
+        for (const fieldName in this.__entity) {
+            const field = this.__entity[fieldName];
+            if (field && field.primary === true) {
+                primaryKeyField = fieldName;
+                break;
+            }
+        }
+
+        if (!primaryKeyField) {
+            throw new Error(`findById error: No primary key defined on entity '${this.__entity.__name}'`);
+        }
+
+        // Build where clause: entity.primaryKey == id
+        const entityParam = 'r'; // Standard parameter name
+        const whereClause = `${entityParam} => ${entityParam}.${primaryKeyField} == $$`;
+
+        // Chain where() and single()
+        return this.where(whereClause, id).single();
+    }
+
     single(){
         // If no clauses were used before single(), seed defaults so SQL is valid
         if(this.__queryObject.script.entityMap.length === 0){
@@ -237,6 +366,55 @@ class queryMethods{
 
       // ------------------------------- FUNCTIONS THAT UPDATE SQL START FROM HERE  -----------------------------------------------------
     // ---------------------------------------------------------------------------------------------------------------------------------------
+
+    // Creates a new empty entity instance ready for insertion
+    // Returns an object with property setters that track changes
+    new(){
+        var newEntity = {
+            __ID : Math.floor((Math.random() * 100000) + 1),
+            __dirtyFields : [],
+            __state : "insert",
+            __entity : this.__entity,
+            __context : this.__context,
+            __name : this.__entity.__name,
+            __proto__ : {}
+        };
+
+        // Set up property setters for all entity fields
+        var $that = this;
+        for (var fieldName in this.__entity) {
+            if(!fieldName.startsWith("__")){
+                var field = this.__entity[fieldName];
+                // Skip navigational properties (relationships)
+                if(!field.isNavigational && field.type !== "hasMany" && field.type !== "hasOne" && field.type !== "hasManyThrough"){
+                    (function(fname, fieldDef){
+                        Object.defineProperty(newEntity, fname, {
+                            enumerable: true,
+                            configurable: true,
+                            set: function(value) {
+                                this.__proto__["_" + fname] = value;
+                                if(!this.__dirtyFields.includes(fname)){
+                                    this.__dirtyFields.push(fname);
+                                }
+                            },
+                            get: function(){
+                                // Apply get function if defined
+                                if(fieldDef && typeof fieldDef.get === "function"){
+                                    return fieldDef.get(this.__proto__["_" + fname]);
+                                }
+                                return this.__proto__["_" + fname];
+                            }
+                        });
+                    })(fieldName, field);
+                }
+            }
+        }
+
+        // Track the entity
+        this.__context.__track(newEntity);
+        return newEntity;
+    }
+
     add(entityValue){
         entityValue.__state = "insert";
         entityValue.__entity = this.__entity;

package/QueryLanguage/queryParameters.js

@@ -0,0 +1,136 @@
+// QueryParameters - Manages parameterized query values
+// Version 1.0.0
+// Provides SQL injection protection through proper parameterization
+
+class QueryParameters {
+    constructor() {
+        this.params = [];
+        this.paramIndex = 0;
+    }
+
+    /**
+     * Add a parameter value and return the placeholder
+     * @param {*} value - The value to add
+     * @param {string} dbType - 'sqlite', 'mysql', or 'postgres'
+     * @returns {string} - The placeholder (? for MySQL/SQLite, $1 for Postgres)
+     */
+    addParam(value, dbType = 'sqlite') {
+        // Validate value is not undefined
+        if (typeof value === 'undefined') {
+            throw new Error(`Parameter value cannot be undefined at index ${this.paramIndex}`);
+        }
+
+        // Add to parameters array
+        this.params.push(value);
+        this.paramIndex++;
+
+        // Return appropriate placeholder based on database type
+        switch(dbType.toLowerCase()) {
+            case 'postgres':
+                return `$${this.paramIndex}`;  // $1, $2, $3...
+            case 'mysql':
+            case 'sqlite':
+            default:
+                return '?';  // ? for MySQL and SQLite
+        }
+    }
+
+    /**
+     * Add multiple parameters (for IN clauses)
+     * @param {Array} values - Array of values
+     * @param {string} dbType - Database type
+     * @returns {string} - Comma-separated placeholders like "?, ?, ?"
+     */
+    addParams(values, dbType = 'sqlite') {
+        if (!Array.isArray(values)) {
+            throw new Error('addParams expects an array');
+        }
+
+        if (values.length === 0) {
+            throw new Error('Cannot create IN clause with empty array');
+        }
+
+        const placeholders = [];
+        for (const value of values) {
+            placeholders.push(this.addParam(value, dbType));
+        }
+
+        return placeholders.join(', ');
+    }
+
+    /**
+     * Get all collected parameters
+     * @returns {Array} - Array of parameter values
+     */
+    getParams() {
+        return this.params;
+    }
+
+    /**
+     * Get parameter count
+     * @returns {number} - Number of parameters
+     */
+    count() {
+        return this.params.length;
+    }
+
+    /**
+     * Reset parameters (called after query execution)
+     */
+    reset() {
+        this.params = [];
+        this.paramIndex = 0;
+    }
+
+    /**
+     * Merge parameters from another QueryParameters instance
+     * Used when combining multiple query clauses
+     * @param {QueryParameters} other - Another QueryParameters instance
+     */
+    merge(other) {
+        if (other && other.params && Array.isArray(other.params)) {
+            this.params.push(...other.params);
+            this.paramIndex += other.params.length;
+        }
+    }
+
+    /**
+     * Validate a value is safe for parameterization
+     * Rejects functions, symbols, and other unsafe types
+     * @param {*} value - Value to validate
+     * @returns {boolean} - True if valid
+     * @throws {Error} - If value is invalid
+     */
+    validateValue(value) {
+        const type = typeof value;
+
+        // Allow null (SQL NULL)
+        if (value === null) {
+            return true;
+        }
+
+        // Allow primitives
+        if (type === 'string' || type === 'number' || type === 'boolean') {
+            return true;
+        }
+
+        // Allow Date objects
+        if (value instanceof Date) {
+            return true;
+        }
+
+        // Allow Buffer (for binary data)
+        if (Buffer.isBuffer(value)) {
+            return true;
+        }
+
+        // Reject everything else (functions, objects, symbols, etc.)
+        throw new Error(
+            `Invalid parameter type: ${type}. ` +
+            `Only primitives, null, Date, and Buffer are allowed. ` +
+            `Received: ${JSON.stringify(value)}`
+        );
+    }
+}
+
+module.exports = QueryParameters;