masterrecord 0.3.46 → 0.3.48

package/Migrations/migrationTemplate.js

@@ -39,10 +39,10 @@ module.exports = ${this.name};
 
     alterColumn(type, name, parent){
         if(type === "up"){
-            this.#up += os.EOL + `     this.alterColumn(table.${name});` 
+            this.#up += os.EOL + `     await this.alterColumn(table.${name});`
         }
         else{
-            this.#down += os.EOL + `     this.alterColumn(table.${name});` 
+            this.#down += os.EOL + `     await this.alterColumn(table.${name});`
         }
     }
     createTable(type, name){
@@ -56,29 +56,29 @@ module.exports = ${this.name};
 
     addColumn(type, name, parent){
         if(type === "up"){
-            this.#up += os.EOL + `     this.addColumn(table.${name});`
+            this.#up += os.EOL + `     await this.addColumn(table.${name});`
         }
         else{
-            this.#down += os.EOL + `     this.addColumn(table.${name});`
+            this.#down += os.EOL + `     await this.addColumn(table.${name});`
         }
     }
     //this.addColumn(table.${parent}.${name});`
    
     dropTable(type, name){
         if(type === "up"){
-            this.#down += os.EOL + `    this.dropTable(table.${name});`
+            this.#down += os.EOL + `    await this.dropTable(table.${name});`
         }
         else{
-            this.#down += os.EOL + `    this.dropTable(table.${name});`
+            this.#down += os.EOL + `    await this.dropTable(table.${name});`
         }
     }
 
     dropColumn(type, name, parent){
         if(type === "up"){
-            this.#up += os.EOL + `     this.dropColumn(table.${name});`
+            this.#up += os.EOL + `     await this.dropColumn(table.${name});`
         }
         else{
-            this.#down += os.EOL + `     this.dropColumn(table.${name});`
+            this.#down += os.EOL + `     await this.dropColumn(table.${name});`
         }
     }
 
@@ -187,7 +187,7 @@ module.exports = ${this.name};
 
                 this.#up += os.EOL + `     ];`;
                 this.#up += os.EOL + `     for (const record of factoryRecords) {`;
-                this.#up += os.EOL + `         this.seed('${tableName}', record);`;
+                this.#up += os.EOL + `         await this.seed('${tableName}', record);`;
                 this.#up += os.EOL + `     }`;
             } else {
                 // Standard individual inserts for non-factory or small batches
@@ -214,10 +214,10 @@ module.exports = ${this.name};
                             const formattedRecord = JSON.stringify(cleanRecord, null, 12)
                                 .split('\n')
                                 .join(os.EOL + '            ');
-                            this.#up += os.EOL + `     this.seed('${tableName}', ${formattedRecord});`;
+                            this.#up += os.EOL + `     await this.seed('${tableName}', ${formattedRecord});`;
                         } else {
                             // Single-line format
-                            this.#up += os.EOL + `     this.seed('${tableName}', ${recordStr});`;
+                            this.#up += os.EOL + `     await this.seed('${tableName}', ${recordStr});`;
                         }
                     }
                 });
@@ -257,7 +257,7 @@ module.exports = ${this.name};
 
         this.#up += os.EOL + `             await existing.save();`;
         this.#up += os.EOL + `         } else {`;
-        this.#up += os.EOL + `             this.seed('${tableName}', ${JSON.stringify(cleanRecord)});`;
+        this.#up += os.EOL + `             await this.seed('${tableName}', ${JSON.stringify(cleanRecord)});`;
         this.#up += os.EOL + `         }`;
         this.#up += os.EOL + `     }`;
     }

package/Migrations/schema.js

@@ -158,7 +158,7 @@ class schema{
     }
     
     // create obj to convert into create sql
-    addColumn(table){
+    async addColumn(table){
         // todo need to work on add column for mysql
         if(table){
             if(this.context.isSQLite){
@@ -168,7 +168,7 @@ class schema{
                 // This allows explicit column definitions to work, not just CLI-generated migrations
                 // Note: No need to set table.realDataType - columnMapping handles type conversion internally
                 var query = queryBuilder.addColum(table);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isMySQL){
@@ -176,7 +176,7 @@ class schema{
                 var queryBuilder = new sqlquery();
                 // Note: No need to set table.realDataType - columnMapping handles type conversion internally
                 var query = queryBuilder.addColum(table);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isPostgres){
@@ -184,14 +184,14 @@ class schema{
                 var queryBuilder = new postgresQuery();
                 // Note: No need to set table.realDataType - columnMapping handles type conversion internally
                 var query = queryBuilder.addColum(table);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
         }
 
         // add column to database
     }
 
-    dropColumn(table){
+    async dropColumn(table){
         if(table){
             if(this.fullTable){
                 // drop column
@@ -199,21 +199,21 @@ class schema{
                     var sqliteQuery = require("./migrationSQLiteQuery");
                     var queryBuilder = new sqliteQuery();
                     var query = queryBuilder.dropColumn(table);
-                    this.context._execute(query);
+                    await this.context._execute(query);
                 }
 
                 if(this.context.isMySQL){
                     var sqlquery = require("./migrationMySQLQuery");
                     var queryBuilder = new sqlquery();
                     var query = queryBuilder.dropColumn(table);
-                    this.context._execute(query);
+                    await 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);
+                    await this.context._execute(query);
                 }
 
             }else{
@@ -237,50 +237,49 @@ class schema{
                     var sqliteQuery = require("./migrationSQLiteQuery");
                     var queryBuilder = new sqliteQuery();
                     var query = queryBuilder.createTable(table);
-                    this.context._execute(query);
+                    await this.context._execute(query);
                 }
 
                 if(this.context.isMySQL){
                     var sqlquery = require("./migrationMySQLQuery");
                     var queryBuilder = new sqlquery();
                     var query = queryBuilder.createTable(table);
-                    this.context._execute(query);
+                    await 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);
+                    await this.context._execute(query);
                 }
 
                 // Create indexes for columns that have .index() defined
-                const self = this;
-                Object.keys(table).forEach(function(key){
+                for(const key of Object.keys(table)){
                     if(typeof table[key] === "object" && table[key].indexes && !key.startsWith('__')){
                         const columnName = table[key].name;
-                        table[key].indexes.forEach(function(indexName){
+                        for(const indexName of table[key].indexes){
                             const indexInfo = {
                                 tableName: tableName,
                                 columnName: columnName,
                                 indexName: indexName
                             };
-                            self.createIndex(indexInfo);
-                        });
+                            await this.createIndex(indexInfo);
+                        }
                     }
-                });
+                }
 
                 // Create composite indexes
                 if (table.__compositeIndexes) {
-                    table.__compositeIndexes.forEach(function(compositeIdx) {
+                    for(const compositeIdx of table.__compositeIndexes){
                         const indexInfo = {
                             tableName: tableName,
                             columns: compositeIdx.columns,
                             indexName: compositeIdx.name,
                             unique: compositeIdx.unique
                         };
-                        self.createCompositeIndex(indexInfo);
-                    });
+                        await this.createCompositeIndex(indexInfo);
+                    }
                 }
             }
         }else{
@@ -297,8 +296,12 @@ class schema{
         const existingNames = new Set((existing || []).map(c => (c.name || c.COLUMN_NAME))); // both engines map to name
         // Add missing columns only (safe path)
         for (var key in table) {
-            if(typeof table[key] === 'object'){
+            // Skip metadata properties (indexes, __compositeIndexes, __name, etc.)
+            if(key === 'indexes' || key.startsWith('__')) continue;
+            if(typeof table[key] === 'object' && !Array.isArray(table[key])){
                 const col = table[key];
+                // Skip if missing name/type (not a valid column definition)
+                if(!col.name || !col.type) continue;
                 // Skip relationships
                 if(col.type === 'hasOne' || col.type === 'hasMany' || col.type === 'hasManyThrough') continue;
                 const colName = (col.relationshipType === 'belongsTo' && col.foreignKey) ? col.foreignKey : col.name;
@@ -315,21 +318,21 @@ class schema{
                         var queryBuilder = new sqliteQuery();
                         // Build a conservative column add (no NOT NULL without default)
                         const add = queryBuilder.addColum({ tableName, name: colName });
-                        this.context._execute(add);
+                        await this.context._execute(add);
                     }
                     if(this.context.isMySQL){
                         var sqlquery = require("./migrationMySQLQuery");
                         var queryBuilder = new sqlquery();
                         newCol.realDataType = queryBuilder.typeManager(col.type);
                         const query = queryBuilder.addColum(newCol);
-                        this.context._execute(query);
+                        await 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);
+                        await this.context._execute(query);
                     }
                 }
             }
@@ -337,8 +340,10 @@ class schema{
         // Detect modifications (nullable/default/type)
         const desiredCols = [];
         for (var key in table) {
-            if(typeof table[key] === 'object'){
+            if(key === 'indexes' || key.startsWith('__')) continue;
+            if(typeof table[key] === 'object' && !Array.isArray(table[key])){
                 const col = table[key];
+                if(!col.name || !col.type) continue;
                 if(col.type === 'hasOne' || col.type === 'hasMany' || col.type === 'hasManyThrough') continue;
                 const colName = (col.relationshipType === 'belongsTo' && col.foreignKey) ? col.foreignKey : col.name;
                 desiredCols.push({ name: colName, col });
@@ -411,7 +416,7 @@ class schema{
                         defPart = ' DEFAULT NULL';
                     }
                     const alter = `ALTER TABLE ${tableName} MODIFY COLUMN ${d.name} ${type} ${nullPart}${defPart}`;
-                    this.context._execute(alter);
+                    await this.context._execute(alter);
                 }
             }
         }
@@ -421,10 +426,10 @@ class schema{
             var queryBuilder = new sqliteQuery();
             // rename old table
             const rename = queryBuilder.renameTable({ tableName, newName: "_temp_alter_column_update" });
-            this.context._execute(rename);
+            await this.context._execute(rename);
             // create new with desired schema
             const create = queryBuilder.createTable(table);
-            this.context._execute(create);
+            await this.context._execute(create);
             // compute common columns
             const oldInfo = await engine.getTableInfo(tableName.replace(/.*/, '_temp_alter_column_update')) || await engine.getTableInfo("_temp_alter_column_update");
             const oldNames = new Set((oldInfo || existing).map(r => r.name));
@@ -433,35 +438,35 @@ class schema{
             if(common.length > 0){
                 const cols = common.join(',');
                 const insert = `INSERT INTO ${tableName} (${cols}) SELECT ${cols} FROM _temp_alter_column_update`;
-                this.context._execute(insert);
+                await this.context._execute(insert);
             }
             const drop = queryBuilder.dropTable("_temp_alter_column_update");
-            this.context._execute(drop);
+            await this.context._execute(drop);
         }
     }
 
 
-    dropTable(table){
+    async dropTable(table){
         if(table){
             if(this.context.isSQLite){
                 var sqliteQuery = require("./migrationSQLiteQuery");
                 var queryBuilder = new sqliteQuery();
                 var query = queryBuilder.dropTable(table.__name);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isMySQL){
                 var sqlquery = require("./migrationMySQLQuery");
                 var queryBuilder = new sqlquery();
                 var query = queryBuilder.dropTable(table.__name);
-                this.context._execute(query);
+                await 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);
+                await this.context._execute(query);
             }
         }
     }
@@ -479,7 +484,7 @@ class schema{
 
 
    //"dbo.People", "Location"
-    alterColumn(table){
+    async alterColumn(table){
         if(table){
             if(this.fullTable){
                 if(this.context.isSQLite){
@@ -488,7 +493,7 @@ class schema{
                     var queryObj = queryBuilder.alterColumn(this.fullTable.new, table);
                     for (var key in queryObj) {
                         var query = queryObj[key];
-                        this.context._execute(query);
+                        await this.context._execute(query);
                     }
                 }
 
@@ -496,14 +501,14 @@ class schema{
                     var sqlquery = require("./migrationMySQLQuery");
                     var queryBuilder = new sqlquery();
                     var query = queryBuilder.alterColumn(table);
-                    this.context._execute(query);
+                    await 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);
+                    await this.context._execute(query);
                 }
 
             }else{
@@ -512,132 +517,132 @@ class schema{
         }
     }
 
-    renameColumn(table){
+    async renameColumn(table){
         if(table){
             if(this.context.isSQLite){
                 var sqliteQuery = require("./migrationSQLiteQuery");
                 var queryBuilder = new sqliteQuery();
                 var query = queryBuilder.renameColumn(table);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isMySQL){
                 var sqlquery = require("./migrationMySQLQuery");
                 var queryBuilder = new sqlquery();
                 var query = queryBuilder.renameColumn(table);
-                this.context._execute(query);
+                await 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);
+                await this.context._execute(query);
             }
         }
     }
 
-    createIndex(indexInfo){
+    async 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);
+                await 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);
+                await 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);
+                await this.context._execute(query);
             }
         }
     }
 
-    dropIndex(indexInfo){
+    async 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);
+                await 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);
+                await 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);
+                await this.context._execute(query);
             }
         }
     }
 
-    createCompositeIndex(indexInfo){
+    async createCompositeIndex(indexInfo){
         if(indexInfo){
             if(this.context.isSQLite){
                 var sqliteQuery = require("./migrationSQLiteQuery");
                 var queryBuilder = new sqliteQuery();
                 var query = queryBuilder.createCompositeIndex(indexInfo);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isMySQL){
                 var sqlquery = require("./migrationMySQLQuery");
                 var queryBuilder = new sqlquery();
                 var query = queryBuilder.createCompositeIndex(indexInfo);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isPostgres){
                 var postgresQuery = require("./migrationPostgresQuery");
                 var queryBuilder = new postgresQuery();
                 var query = queryBuilder.createCompositeIndex(indexInfo);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
         }
     }
 
-    dropCompositeIndex(indexInfo){
+    async dropCompositeIndex(indexInfo){
         if(indexInfo){
             if(this.context.isSQLite){
                 var sqliteQuery = require("./migrationSQLiteQuery");
                 var queryBuilder = new sqliteQuery();
                 var query = queryBuilder.dropCompositeIndex(indexInfo);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isMySQL){
                 var sqlquery = require("./migrationMySQLQuery");
                 var queryBuilder = new sqlquery();
                 var query = queryBuilder.dropCompositeIndex(indexInfo);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
 
             if(this.context.isPostgres){
                 var postgresQuery = require("./migrationPostgresQuery");
                 var queryBuilder = new postgresQuery();
                 var query = queryBuilder.dropCompositeIndex(indexInfo);
-                this.context._execute(query);
+                await this.context._execute(query);
             }
         }
     }
 
-    seed(tableName, rows){
+    async seed(tableName, rows){
         if(!tableName || !rows){ return; }
         const items = Array.isArray(rows) ? rows : [rows];
 
@@ -649,7 +654,7 @@ class schema{
                 // 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);
+                await this.context._execute(idempotentQuery);
             }
         }
 
@@ -660,7 +665,7 @@ class schema{
                 // 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);
+                await this.context._execute(idempotentQuery);
             }
         }
 
@@ -672,7 +677,7 @@ class schema{
                 // 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);
+                await this.context._execute(idempotentQuery);
             }
         }
     }
@@ -682,7 +687,7 @@ class schema{
      * @param {string} tableName - Name of the table
      * @param {Array} rows - Array of data objects
      */
-    bulkSeed(tableName, rows){
+    async bulkSeed(tableName, rows){
         if(!tableName || !rows || rows.length === 0){ return; }
 
         if(this.context.isSQLite){
@@ -691,7 +696,7 @@ class schema{
             const query = queryBuilder.bulkInsertSeedData(tableName, rows);
             if(query){
                 const idempotentQuery = query.replace(/^INSERT INTO/, 'INSERT OR IGNORE INTO');
-                this.context._execute(idempotentQuery);
+                await this.context._execute(idempotentQuery);
             }
         }
 
@@ -701,7 +706,7 @@ class schema{
             const query = queryBuilder.bulkInsertSeedData(tableName, rows);
             if(query){
                 const idempotentQuery = query.replace(/^INSERT INTO/, 'INSERT IGNORE INTO');
-                this.context._execute(idempotentQuery);
+                await this.context._execute(idempotentQuery);
             }
         }
 
@@ -711,7 +716,7 @@ class schema{
             const query = queryBuilder.bulkInsertSeedData(tableName, rows);
             if(query){
                 const idempotentQuery = query + ' ON CONFLICT DO NOTHING';
-                this.context._execute(idempotentQuery);
+                await this.context._execute(idempotentQuery);
             }
         }
     }

package/context.js

@@ -1714,7 +1714,7 @@ class context {
      * context._execute('CREATE INDEX idx_user_email ON User(email)');
      */
     _execute(query) {
-        this._SQLEngine._execute(query);
+        return this._SQLEngine._execute(query);
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.46",
+  "version": "0.3.48",
   "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/readme.md

@@ -3369,6 +3369,27 @@ user.name = null;  // Error if name is { nullable: false }
 
 ## Changelog
 
+### Version 0.3.48 (2026-02-20) - FIX: Complete Async Migration Pipeline for MySQL/PostgreSQL
+
+#### Bug Fixed: Migration methods not properly awaiting async database operations
+- **FIXED**: All migration schema methods (`createTable`, `addColumn`, `dropColumn`, `dropTable`, `alterColumn`, `renameColumn`, `createIndex`, `dropIndex`, `createCompositeIndex`, `dropCompositeIndex`, `seed`, `bulkSeed`) are now fully `async` and properly `await` all database operations
+  - **Root Cause**: SQLite's `_execute()` is synchronous, but MySQL/PostgreSQL return Promises. Migration methods were calling `this.context._execute()` without `await`, causing operations to run out of order (e.g., CREATE INDEX running before CREATE TABLE finished)
+  - **Solution**: Made all schema methods async, added `await` to every `_execute()` call, converted `forEach` loops to `for...of` for proper async iteration
+- **FIXED**: `context._execute()` now properly returns the engine's Promise (`return this._SQLEngine._execute(query)`)
+- **FIXED**: Added `_execute()` method to MySQL and PostgreSQL engines (previously only existed on SQLite)
+- **FIXED**: `syncTable()` no longer crashes on metadata properties (`indexes`, `__compositeIndexes`) — now filters them out before column iteration
+- **FIXED**: Migration template now generates `await` for all method calls in migration files
+- **FIXED**: Unhandled promise rejection crash — MySQL/PostgreSQL `_initPromise` now has `.catch(() => {})` to prevent Node.js crash before `_ensureReady()` can handle errors
+- **FIXED**: Added `_ready` flag to prevent duplicate `_ensureReady()` execution
+
+#### Files Modified
+1. **`Migrations/schema.js`** - All methods async, all `_execute` calls awaited, forEach→for...of, syncTable metadata filtering, `_ready` flag
+2. **`Migrations/migrationTemplate.js`** - All generated method calls now include `await`
+3. **`mySQLEngine.js`** - Added `_execute()` method
+4. **`postgresEngine.js`** - Added `_execute()` method
+5. **`context.js`** - `_execute()` returns engine result, `.catch()` on `_initPromise`
+6. **`package.json`** - Updated to v0.3.48
+
 ### Version 0.3.44 (2026-02-20) - FIX: MySQL/PostgreSQL Auto-Create Database During Migrations
 
 #### Bug Fixed: `update-database` failing when database doesn't exist yet (MySQL & PostgreSQL)