masterrecord 0.2.9 → 0.2.11

package/Migrations/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// version 0.0.6
+// version 0.0.7
 // https://docs.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/
 // how to add environment variables on cli call example - master=development masterrecord add-migration auth authContext
 
@@ -74,6 +74,66 @@ program.option('-V', 'output the version');
 
   });
 
+  program
+  .command('ensure-database <contextFileName>')
+  .alias('ed')
+  .description('Ensure the target database exists for the given context (MySQL)')
+  .action(function(contextFileName){
+    var executedLocation = process.cwd();
+    contextFileName = contextFileName.toLowerCase();
+    var migration = new Migration();
+    try{
+      var search = `${executedLocation}/**/*${contextFileName}_contextSnapShot.json`;
+      var files = globSearch.sync(search, executedLocation);
+      var file = files && files[0];
+      if(!file){
+        console.log(`Error - Cannot read or find Context snapshot '${contextFileName}_contextSnapShot.json' in '${executedLocation}'.`);
+        return;
+      }
+      var contextSnapshot;
+      try{
+        contextSnapshot = require(file);
+      }catch(_){
+        console.log(`Error - Cannot read context snapshot at '${file}'.`);
+        return;
+      }
+      // Find latest migration file (so we can use its class which extends schema)
+      var searchMigration = `${contextSnapshot.migrationFolder}/**/*_migration.js`;
+      var migrationFiles = globSearch.sync(searchMigration, contextSnapshot.migrationFolder);
+      if(!(migrationFiles && migrationFiles.length)){
+        console.log("Error - Cannot read or find migration file");
+        return;
+      }
+      var mFiles = migrationFiles.slice().sort(function(a, b){
+        return __getMigrationTimestamp(a) - __getMigrationTimestamp(b);
+      });
+      var mFile = mFiles[mFiles.length -1];
+
+      let ContextCtor;
+      try{
+        ContextCtor = require(contextSnapshot.contextLocation);
+      }catch(_){
+        console.log(`Error - Cannot load Context file at '${contextSnapshot.contextLocation}'.`);
+        return;
+      }
+
+      // Use the migration class (extends schema) so createdatabase is available
+      var MigrationCtor = require(mFile);
+      var mig = new MigrationCtor(ContextCtor);
+      if(typeof mig.createdatabase === 'function'){
+        try{ mig.createdatabase(); }catch(_){ /* best-effort */ }
+        console.log('database ensured');
+      } else if(typeof mig.createDatabase === 'function'){
+        try{ mig.createDatabase(); }catch(_){ }
+        console.log('database ensured');
+      } else {
+        console.log('Error - Migration class missing createDatabase method');
+      }
+    }catch(e){
+      console.log('Error - Cannot read or find file ', e);
+    }
+  });
+
   // program
   // .command('create-database <contextFileName> <dbName>')
   // .alias('cd')
@@ -509,6 +569,96 @@ program.option('-V', 'output the version');
   });
 
 
+  program
+  .command('update-database-all')
+  .alias('uda')
+  .description('Scan the project for *Context.js files and run update-database on each')
+  .action(function(){
+    var executedLocation = process.cwd();
+    try{
+      // Find all Context files (e.g., chatContext.js)
+      var allFiles = globSearch.sync(`${executedLocation}/**/*Context.js`, executedLocation);
+      if(!(allFiles && allFiles.length)){
+        console.log('No Context files found.');
+        return;
+      }
+      // Deduplicate by basename (case-insensitive)
+      var seen = new Set();
+      var contextFiles = [];
+      for(const f of allFiles){
+        var name = path.basename(f).toLowerCase();
+        if(!seen.has(name)){
+          seen.add(name);
+          contextFiles.push(f);
+        }
+      }
+      var migration = new Migration();
+      // Process each context independently
+      for(const ctxFile of contextFiles){
+        try{
+          var base = path.basename(ctxFile);
+          var ctxName = base.replace(/\.js$/i, '').toLowerCase();
+          // Locate snapshot for this context
+          var snapMatches = globSearch.sync(`${executedLocation}/**/*${ctxName}_contextSnapShot.json`, executedLocation);
+          var snapFile = snapMatches && snapMatches[0];
+          if(!snapFile){
+            console.log(`Skipping ${ctxName}: snapshot not found. Run 'masterrecord enable-migrations ${ctxName}'.`);
+            continue;
+          }
+          var contextSnapshot;
+          try{ contextSnapshot = require(snapFile); }catch(_){
+            console.log(`Skipping ${ctxName}: cannot read context snapshot at '${snapFile}'.`);
+            continue;
+          }
+          // Get migration files for this snapshot folder
+          var searchMigration = `${contextSnapshot.migrationFolder}/**/*_migration.js`;
+          var migrationFiles = globSearch.sync(searchMigration, contextSnapshot.migrationFolder);
+          if(!(migrationFiles && migrationFiles.length)){
+            console.log(`Skipping ${ctxName}: no migration files found.`);
+            continue;
+          }
+          // Pick latest
+          var mFiles = migrationFiles.slice().sort(function(a, b){
+            return __getMigrationTimestamp(a) - __getMigrationTimestamp(b);
+          });
+          var mFile = mFiles[mFiles.length - 1];
+
+          var ContextCtor;
+          try{ ContextCtor = require(contextSnapshot.contextLocation); }catch(_){
+            console.log(`Skipping ${ctxName}: cannot load Context at '${contextSnapshot.contextLocation}'.`);
+            continue;
+          }
+          var contextInstance;
+          try{ contextInstance = new ContextCtor(); }catch(_){
+            console.log(`Skipping ${ctxName}: failed to construct Context.`);
+            continue;
+          }
+          var migrationProjectFile = require(mFile);
+          var newMigrationProjectInstance = new migrationProjectFile(ContextCtor);
+          var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+          var tableObj = migration.buildUpObject(contextSnapshot.schema, cleanEntities);
+          // Run up for this context
+          newMigrationProjectInstance.up(tableObj);
+          // Update snapshot
+          var snap = {
+            file : contextSnapshot.contextLocation,
+            executedLocation : executedLocation,
+            context : contextInstance,
+            contextEntities : cleanEntities,
+            contextFileName: ctxName
+          }
+          migration.createSnapShot(snap);
+          console.log(`database updated for ${ctxName}`);
+        }catch(errCtx){
+          console.log('Error updating context: ', errCtx);
+        }
+      }
+    }catch(e){
+      console.log('Error - Cannot read or find file ', e);
+    }
+  });
+
+
 program.parse(process.argv);
 
 // Handle manual '-V' alias

package/Migrations/schema.js

@@ -3,6 +3,7 @@ class schema{
 
     constructor(context){
         this.context = new context();
+        this._dbEnsured = false;
     }
 
 
@@ -10,6 +11,10 @@ class schema{
         if(table){
             this.fullTable = table.___table;
         }
+        // Ensure backing database exists for MySQL before running any DDL
+        if(this.context && this.context.isMySQL && this._dbEnsured !== true){
+            try{ this.createDatabase(); }catch(_){ /* best-effort */ }
+        }
     }
     
     // create obj to convert into create sql
@@ -253,6 +258,39 @@ class schema{
         }
     }
 
+    // EnsureCreated equivalent for MySQL: create DB if missing
+    createDatabase(){
+        try{
+            if(!(this.context && this.context.isMySQL)){ return; }
+            const MySQLClient = require('masterrecord/mySQLSyncConnect');
+            const client = this.context.db; // main client (may not be connected yet)
+            if(!client || !client.config || !client.config.database){ return; }
+            const dbName = client.config.database;
+            // Build server-level connection (no database)
+            const baseConfig = { ...client.config };
+            delete baseConfig.database;
+            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}'`);
+            const exists = Array.isArray(check) ? check.length > 0 : !!check?.length;
+            if(!exists){
+                // Create with sensible defaults
+                admin.query(`CREATE DATABASE \`${dbName}\` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
+            }
+            admin.close();
+            this._dbEnsured = true;
+        }catch(err){
+            // Non-fatal: migrations may still proceed if DB already exists or permissions blocked
+            try{ console.error(err); }catch(_){ }
+        }
+    }
+
+    // Alias for consistency with user expectation
+    createdatabase(table){
+        return this.createDatabase(table);
+    }
+
 
    //"dbo.People", "Location"
     alterColumn(table){
@@ -318,7 +356,15 @@ class schema{
                 const esc = String(v).replace(/'/g, "''");
                 return `'${esc}'`;
             }).join(", ");
-            const sql = `INSERT INTO ${tableName} (${colList}) VALUES (${vals})`;
+            // 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})`;
+            }
             this.context._execute(sql);
         }
     }

package/mySQLEngine.js

@@ -574,14 +574,24 @@ class SQLLiteEngine {
             this.db.connect(this.db);
             const res = this.db.query(query);
             if(res === null){
-                console.error('MySQL execute skipped: connection not defined');
+                const dbName = (this.db && this.db.config && this.db.config.database) ? this.db.config.database : '(unknown)';
+                if(this.db && this.db.lastErrorCode === 'ER_BAD_DB_ERROR'){
+                    console.error(`MySQL execute skipped: database '${dbName}' does not exist`);
+                }else{
+                    console.error('MySQL execute skipped: connection not defined');
+                }
                 return null;
             }
             return res;
         }catch(err){
             const code = err && err.code ? err.code : '';
             if(code === 'ER_BAD_DB_ERROR' || code === 'ECONNREFUSED' || code === 'PROTOCOL_CONNECTION_LOST'){
-                console.error('MySQL execute skipped: connection not defined');
+                const dbName = (this.db && this.db.config && this.db.config.database) ? this.db.config.database : '(unknown)';
+                if(code === 'ER_BAD_DB_ERROR'){
+                    console.error(`MySQL execute skipped: database '${dbName}' does not exist`);
+                } else {
+                    console.error('MySQL execute skipped: connection not defined');
+                }
                 return null;
             }
             console.error(err);

package/mySQLSyncConnect.js

@@ -1,4 +1,4 @@
-// version : 0.0.3
+// version : 0.0.4
 
 var MySql = require('sync-mysql2');
 
@@ -9,6 +9,8 @@ class MySQLClient {
             delete this.config.type;
         }
         this.connection = null;
+        this.lastErrorCode = null;
+        this.lastErrorMessage = null;
     }
 
     connect() {
@@ -19,7 +21,14 @@ class MySQLClient {
             }
         } catch (err) {
             // Swallow connection errors and leave connection undefined so callers can react gracefully
-            console.error('MySQL connect error:', err && err.code ? err.code : err);
+            this.lastErrorCode = err && err.code ? err.code : null;
+            this.lastErrorMessage = err && err.message ? err.message : String(err);
+            if(this.lastErrorCode === 'ER_BAD_DB_ERROR'){
+                const dbName = this.config && this.config.database ? this.config.database : '(unknown)';
+                console.error(`MySQL connect error: database '${dbName}' does not exist`);
+            }else{
+                console.error('MySQL connect error:', this.lastErrorCode || this.lastErrorMessage);
+            }
             this.connection = null;
             return null;
         }
@@ -35,20 +44,36 @@ class MySQLClient {
             return jj;
         } catch (err) {
             // If the underlying driver surfaces bad DB or network errors, normalize to null
-            const code = err && err.code ? err.code : '';
-            if(code === 'ER_BAD_DB_ERROR' || code === 'ECONNREFUSED' || code === 'PROTOCOL_CONNECTION_LOST'){
-                console.error('MySQL query skipped due to connection not defined');
-                return null;
+            this.lastErrorCode = err && err.code ? err.code : null;
+            this.lastErrorMessage = err && err.message ? err.message : String(err);
+            if(this.lastErrorCode === 'ER_BAD_DB_ERROR'){
+                const dbName = this.config && this.config.database ? this.config.database : '(unknown)';
+                console.error(`MySQL error: database '${dbName}' does not exist`);
+            } else if(this.lastErrorCode === 'ECONNREFUSED' || this.lastErrorCode === 'PROTOCOL_CONNECTION_LOST'){
+                console.error('MySQL connection error:', this.lastErrorCode);
+            } else {
+                console.error(err);
             }
-            console.error(err);
             return null;
         }
 
     }
 
     close() {
-        if (this.connection) {
-            this.connection.end();
+        try {
+            if (!this.connection) { return; }
+            if (typeof this.connection.finishAll === 'function') {
+                // Drain any pending RPC calls
+                try { this.connection.finishAll(); } catch(_) { /* ignore */ }
+            }
+            if (typeof this.connection.end === 'function') {
+                try { this.connection.end(); } catch(_) { /* ignore */ }
+            } else if (typeof this.connection.close === 'function') {
+                try { this.connection.close(); } catch(_) { /* ignore */ }
+            } else if (typeof this.connection.dispose === 'function') {
+                try { this.connection.dispose(); } catch(_) { /* ignore */ }
+            }
+        } finally {
             this.connection = null;
         }
     }

package/package.json

@@ -9,7 +9,7 @@
     "app-root-path": "^3.1.0",
     "better-sqlite3": "^12.4.1"
   },
-  "version": "0.2.9",
+  "version": "0.2.11",
   "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 ",
   "homepage": "https://github.com/Tailor/MasterRecord#readme",
   "repository": {