masterrecord 0.3.47 → 0.3.49

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/migrations.js

@@ -201,6 +201,9 @@ class Migrations{
 
     #findNewIndexes(tables){
         tables.forEach(function (item, index) {
+            // Skip new tables — createTable() in schema.js already creates their indexes
+            if(item.newTables && item.newTables.length > 0) return;
+
             if(item.new && item.old){
                 Object.keys(item.new).forEach(function (key) {
                     if(typeof item.new[key] === "object" && item.new[key].indexes){
@@ -289,6 +292,9 @@ class Migrations{
 
     #findNewCompositeIndexes(tables) {
         tables.forEach(function (item, index) {
+            // Skip new tables — createTable() in schema.js already creates their composite indexes
+            if(item.newTables && item.newTables.length > 0) return;
+
             if (item.new && item.old) {
                 const newComposite = item.new.__compositeIndexes || [];
                 const oldComposite = item.old.__compositeIndexes || [];
@@ -307,17 +313,6 @@ class Migrations{
                         });
                     }
                 });
-            } else if (item.new && !item.old) {
-                // New table - all composite indexes are new
-                const composites = item.new.__compositeIndexes || [];
-                composites.forEach(function(idx) {
-                    item.newCompositeIndexes.push({
-                        tableName: item.name,
-                        columns: idx.columns,
-                        indexName: idx.name,
-                        unique: idx.unique
-                    });
-                });
             }
         });
         return tables;

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{
@@ -319,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);
                     }
                 }
             }
@@ -417,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);
                 }
             }
         }
@@ -427,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));
@@ -439,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);
             }
         }
     }
@@ -485,7 +484,7 @@ class schema{
 
 
    //"dbo.People", "Location"
-    alterColumn(table){
+    async alterColumn(table){
         if(table){
             if(this.fullTable){
                 if(this.context.isSQLite){
@@ -494,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);
                     }
                 }
 
@@ -502,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{
@@ -518,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];
 
@@ -655,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);
             }
         }
 
@@ -666,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);
             }
         }
 
@@ -678,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);
             }
         }
     }
@@ -688,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){
@@ -697,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);
             }
         }
 
@@ -707,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);
             }
         }
 
@@ -717,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.47",
+  "version": "0.3.49",
   "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": {