masterrecord 0.2.19 → 0.2.21

package/Migrations/cli.js

@@ -191,24 +191,40 @@ program.option('-V', 'output the version');
           return;
         }
 
+        // Resolve relative paths from the snapshot directory (portable snapshots)
+        const snapDir = path.dirname(file);
+        const contextAbs = path.resolve(snapDir, contextSnapshot.contextLocation || '');
+        const migBase = path.resolve(snapDir, contextSnapshot.migrationFolder || '.');
+
         let ContextCtor;
         try{
-          ContextCtor = require(contextSnapshot.contextLocation);
+          ContextCtor = require(contextAbs);
         }catch(_){
-          console.log(`Error - Cannot load Context file at '${contextSnapshot.contextLocation}'.`);
+          console.log(`Error - Cannot load Context file at '${contextAbs}'.`);
           return;
         }
         let contextInstance;
         try{
           contextInstance = new ContextCtor();
         }catch(_){
-          console.log(`Error - Failed to construct Context from '${contextSnapshot.contextLocation}'.`);
+          console.log(`Error - Failed to construct Context from '${contextAbs}'.`);
           return;
         }
         var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+
+        // Skip if no changes between snapshot schema and current entities
+        const has = migration.hasChanges(contextSnapshot.schema || [], cleanEntities || []);
+        if(!has){
+          console.log(`No changes detected for ${path.basename(contextAbs)}. Skipping.`);
+          return;
+        }
+
         var newEntity = migration.template(name, contextSnapshot.schema, cleanEntities);
+        if(!fs.existsSync(migBase)){
+          try{ fs.mkdirSync(migBase, { recursive: true }); }catch(_){ /* ignore */ }
+        }
         var migrationDate = Date.now();
-        var outputFile = `${contextSnapshot.migrationFolder}/${migrationDate}_${name}_migration.js`
+        var outputFile = `${migBase}/${migrationDate}_${name}_migration.js`
         fs.writeFile(outputFile, newEntity, 'utf8', function (err) {
           if (err) return console.log("--- Error running cammand, re-run command add-migration ---- ", err);
         });
@@ -561,6 +577,67 @@ program.option('-V', 'output the version');
   });
 
 
+  program
+  .command('add-migration-all <name>')
+  .alias('ama')
+  .description('Create a migration with the given name for all detected contexts')
+  .action(function(name){
+    var executedLocation = process.cwd();
+    try{
+      var snapshotFiles = globSearch.sync('**/*_contextSnapShot.json', { cwd: executedLocation, dot: true, windowsPathsNoEscape: true, nocase: true });
+      if(!(snapshotFiles && snapshotFiles.length)){
+        console.log('No context snapshots found. Run enable-migrations-all first.');
+        return;
+      }
+      var created = 0;
+      for(const snapRel of snapshotFiles){
+        try{
+          const snapFile = path.resolve(executedLocation, snapRel);
+          let cs;
+          try{ cs = require(snapFile); }catch(_){ continue; }
+          const snapDir = path.dirname(snapFile);
+          const contextAbs = path.resolve(snapDir, cs.contextLocation || '');
+          const migBase = path.resolve(snapDir, cs.migrationFolder || '.');
+          // Load context
+          let ContextCtor;
+          try{ ContextCtor = require(contextAbs); }catch(_){
+            console.log(`Skipping: cannot load Context at '${contextAbs}'.`);
+            continue;
+          }
+          let contextInstance;
+          try{ contextInstance = new ContextCtor(); }catch(_){
+            console.log(`Skipping: failed to construct Context from '${contextAbs}'.`);
+            continue;
+          }
+          var migration = new Migration();
+          var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+          // If no changes, skip with message
+          const has = migration.hasChanges(cs.schema || [], cleanEntities || []);
+          if(!has){
+            console.log(`No changes detected for ${path.basename(contextAbs)}. Skipping.`);
+            continue;
+          }
+          var newEntity = migration.template(name, cs.schema, cleanEntities);
+          if(!fs.existsSync(migBase)){
+            try{ fs.mkdirSync(migBase, { recursive: true }); }catch(_){ /* ignore */ }
+          }
+          var migrationDate = Date.now();
+          var outputFile = path.join(migBase, `${migrationDate}_${name}_migration.js`);
+          fs.writeFileSync(outputFile, newEntity, 'utf8');
+          console.log(`Created migration '${path.basename(outputFile)}' for ${path.basename(contextAbs)}`);
+          created++;
+        }catch(err){
+          console.log('Skipping snapshot due to error: ', err);
+        }
+      }
+      if(created === 0){
+        console.log('No migrations created.');
+      }
+    }catch(e){
+      console.log('Error - Cannot create migrations for all contexts ', e);
+    }
+  });
+
   program
   .command('update-database-all')
   .alias('uda')
@@ -580,20 +657,21 @@ program.option('-V', 'output the version');
         const snapFile = path.resolve(executedLocation, snapRel);
         let cs;
         try{ cs = require(snapFile); }catch(_){ continue; }
+        const snapDir = path.dirname(snapFile);
+        const contextAbs = path.resolve(snapDir, cs.contextLocation || '');
+        let migBase = path.resolve(snapDir, cs.migrationFolder || '.');
         const nameFromPath = path.basename(snapFile).replace(/_contextSnapShot\.json$/i, '').toLowerCase();
-        const ctxName = (cs && cs.contextLocation)
-          ? path.basename(cs.contextLocation).replace(/\.js$/i, '').toLowerCase()
-          : nameFromPath;
+        const ctxName = contextAbs ? path.basename(contextAbs).replace(/\.js$/i, '').toLowerCase() : nameFromPath;
         // Find migrations in snapshot's migrationFolder; fallback to <ContextDir>/db/migrations
-        let migRel = globSearch.sync('**/*_migration.js', { cwd: cs.migrationFolder, dot: true, windowsPathsNoEscape: true, nocase: true }) || [];
+        let migRel = globSearch.sync('**/*_migration.js', { cwd: migBase, dot: true, windowsPathsNoEscape: true, nocase: true }) || [];
         if(!(migRel && migRel.length)){
-          const defaultFolder = path.join(path.dirname(cs.contextLocation || snapFile), 'db', 'migrations');
+          const defaultFolder = path.join(path.dirname(contextAbs || snapFile), 'db', 'migrations');
           migRel = globSearch.sync('**/*_migration.js', { cwd: defaultFolder, dot: true, windowsPathsNoEscape: true, nocase: true }) || [];
-          if(migRel && migRel.length){ cs.migrationFolder = defaultFolder; }
+          if(migRel && migRel.length){ migBase = defaultFolder; }
         }
-        const migs = migRel.map(f => path.resolve(cs.migrationFolder, f));
+        const migs = migRel.map(f => path.resolve(migBase, f));
         if(!groups[ctxName]) groups[ctxName] = [];
-        groups[ctxName].push({ snapFile, cs, ctxName, migs });
+        groups[ctxName].push({ snapFile, snapDir, cs, ctxName, migs, contextAbs, migBase });
       }
 
       var migration = new Migration();
@@ -614,8 +692,8 @@ program.option('-V', 'output the version');
           var mFile = mFiles[mFiles.length - 1];
 
           var ContextCtor;
-          try{ ContextCtor = require(entry.cs.contextLocation); }catch(_){
-            console.log(`Skipping ${entry.ctxName}: cannot load Context at '${entry.cs.contextLocation}'.`);
+          try{ ContextCtor = require(entry.contextAbs); }catch(_){
+            console.log(`Skipping ${entry.ctxName}: cannot load Context at '${entry.contextAbs}'.`);
             continue;
           }
           var contextInstance;
@@ -629,7 +707,7 @@ program.option('-V', 'output the version');
           var tableObj = migration.buildUpObject(entry.cs.schema, cleanEntities);
           newMigrationProjectInstance.up(tableObj);
           var snap = {
-            file : entry.cs.contextLocation,
+            file : entry.contextAbs,
             executedLocation : executedLocation,
             context : contextInstance,
             contextEntities : cleanEntities,
@@ -646,6 +724,58 @@ program.option('-V', 'output the version');
     }
   });
 
+  program
+  .command('enable-migrations-all')
+  .alias('ema')
+  .description('Enable migrations for all detected MasterRecord Context files')
+  .action(function(){
+    var executedLocation = process.cwd();
+    try{
+      // Find candidate Context files
+      var candidates = globSearch.sync('**/*Context.js', { cwd: executedLocation, dot: true, windowsPathsNoEscape: true, nocase: true }) || [];
+      if(!(candidates && candidates.length)){
+        console.log('No Context files found.');
+        return;
+      }
+      var seen = new Set();
+      var enabled = 0;
+      var migration = new Migration();
+      for(const rel of candidates){
+        try{
+          const abs = path.resolve(executedLocation, rel);
+          // Skip node_modules
+          if(abs.indexOf('node_modules') !== -1){ continue; }
+          // Heuristic filter: file must look like a MasterRecord context
+          let text = '';
+          try{ text = fs.readFileSync(abs, 'utf8'); }catch(_){ continue; }
+          const looksLikeContext = /extends\s+masterrecord\.context/i.test(text) || /require\(['"]masterrecord['"]\)/i.test(text);
+          if(!looksLikeContext){ continue; }
+          const ctxName = path.basename(abs).replace(/\.js$/i,'');
+          const key = ctxName.toLowerCase();
+          if(seen.has(key)){ continue; }
+          seen.add(key);
+          // Create snapshot relative to the context file directory
+          var snap = {
+            file : abs,
+            executedLocation : executedLocation,
+            contextEntities : [],
+            contextFileName: key
+          };
+          migration.createSnapShot(snap);
+          console.log(`migrations enabled for ${ctxName}`);
+          enabled++;
+        }catch(err){
+          console.log('Skipping candidate due to error: ', err);
+        }
+      }
+      if(enabled === 0){
+        console.log('No eligible MasterRecord Contexts detected.');
+      }
+    }catch(e){
+      console.log('Error - Failed to enable migrations for all contexts ', e);
+    }
+  });
+
 
 program.parse(process.argv);
 

package/Migrations/migrations.js

@@ -218,10 +218,14 @@ class Migrations{
         }
     
         const snapshotPath = path.join(migrationsDirectory, `${snap.contextFileName}_contextSnapShot.json`);
+        // Store relative paths (portable): values are relative to the snapshot file directory (migrationsDirectory)
+        const relContextLocation = path.relative(migrationsDirectory, snap.file);
+        const relMigrationFolder = '.'; // the snapshot sits inside migrationsDirectory
+        const relSnapshotLocation = path.basename(snapshotPath);
         var content = {
-            contextLocation: snap.file,
-            migrationFolder: migrationsDirectory,
-            snapShotLocation: snapshotPath,
+            contextLocation: relContextLocation,
+            migrationFolder: relMigrationFolder,
+            snapShotLocation: relSnapshotLocation,
             schema : snap.contextEntities
         };
     
@@ -273,6 +277,22 @@ class Migrations{
         return tableObj;
     }
 
+    // Returns true if there are any changes between old and new schema
+    hasChanges(oldSchema, newSchema){
+        const tables = this.#buildMigrationObject(oldSchema, newSchema);
+        for(const t of tables){
+            if(!t) continue;
+            if((t.newTables && t.newTables.length) ||
+               (t.newColumns && t.newColumns.length) ||
+               (t.deletedColumns && t.deletedColumns.length) ||
+               (t.updatedColumns && t.updatedColumns.length) ||
+               (t.old === null) || (t.new === null)){
+                return true;
+            }
+        }
+        return false;
+    }
+
     template(name, oldSchema, newSchema){
         var MT = new MigrationTemplate(name);
         var tables = this.#buildMigrationObject(oldSchema, newSchema);
@@ -317,7 +337,6 @@ class Migrations{
        return MT.get();
     }
 
-
 }
 
 module.exports = Migrations;

package/package.json

@@ -9,7 +9,7 @@
     "app-root-path": "^3.1.0",
     "better-sqlite3": "^12.4.1"
   },
-  "version": "0.2.19",
+  "version": "0.2.21",
   "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": {

package/readme.md

@@ -179,4 +179,106 @@ Notes:
 - For large SQLite tables, a rebuild copies data; consider maintenance windows.
 - Use `master=development masterrecord get-migrations AppContext` to inspect migration order.
 
+## Multi-context (multi-database) projects
+
+When your project defines multiple Context files (e.g., `userContext.js`, `modelContext.js`, `mailContext.js`, `chatContext.js`) across different packages or feature directories, MasterRecord can auto-detect and operate on all of them.
+
+### New bulk commands
+
+- enable-migrations-all (alias: ema)
+  - Scans the project for MasterRecord Context files (heuristic) and enables migrations for each by writing a portable snapshot next to the context at `<ContextDir>/db/migrations/<context>_contextSnapShot.json`.
+
+- add-migration-all <Name> (alias: ama)
+  - Creates a migration named `<Name>` (e.g., `Init`) for every detected context that has a snapshot. Migrations are written into each context’s own migrations folder.
+
+- update-database-all (alias: uda)
+  - Applies the latest migration for every detected context with migrations.
+
+- update-database-down <ContextName> (alias: udd)
+  - Runs the latest migration’s `down()` for the specified context.
+
+- update-database-target <migrationFileName> (alias: udt)
+  - Rolls back migrations newer than the given migration file within that context’s migrations folder.
+
+- ensure-database <ContextName> (alias: ed)
+  - For MySQL contexts, ensures the database exists (like EF’s `Database.EnsureCreated`). Auto-detects connection info from your Context env settings.
+
+### Portable snapshots (no hardcoded absolute paths)
+
+Snapshots are written with relative paths, so moving/renaming the project root does not break CLI resolution:
+- `contextLocation`: path from the migrations folder to the Context file
+- `migrationFolder`: `.` (the snapshot resides in the migrations folder)
+- `snapShotLocation`: the snapshot filename
+
+### Typical flow for multiple contexts
+
+1) Enable migrations everywhere:
+```bash
+# macOS/Linux
+master=development masterrecord enable-migrations-all
+
+# Windows PowerShell
+$env:master = 'development'
+masterrecord enable-migrations-all
+```
+
+2) Create an initial migration for all contexts:
+```bash
+# macOS/Linux
+master=development masterrecord add-migration-all Init
+
+# Windows PowerShell
+$env:master = 'development'
+masterrecord add-migration-all Init
+```
+
+3) Apply migrations everywhere:
+```bash
+# macOS/Linux
+master=development masterrecord update-database-all
+
+# Windows PowerShell
+$env:master = 'development'
+masterrecord update-database-all
+```
+
+4) Inspect migrations for a specific context:
+```bash
+# macOS/Linux
+master=development masterrecord get-migrations userContext
+
+# Windows PowerShell
+$env:master = 'development'
+masterrecord get-migrations userContext
+```
+
+5) Roll back latest for a specific context:
+```bash
+# macOS/Linux
+master=development masterrecord update-database-down userContext
+
+# Windows PowerShell
+$env:master = 'development'
+masterrecord update-database-down userContext
+```
+
+### Environment selection (cross-platform)
+- macOS/Linux prefix: `master=development ...` or `NODE_ENV=development ...`
+- Windows PowerShell:
+```powershell
+$env:master = 'development'
+masterrecord update-database-all
+```
+- Windows cmd.exe:
+```cmd
+set master=development && masterrecord update-database-all
+```
+
+### Notes and tips
+- Each Context should define its own env settings and tables; `update-database-all` operates context-by-context so separate databases are handled cleanly.
+- For SQLite contexts, the `connection` path will be created if the directory does not exist.
+- For MySQL contexts, `ensure-database <ContextName>` can create the DB (permissions required) before migrations run.
+- If you rename/move the project root, re-run `enable-migrations-all` or any single-context command once; snapshots use relative paths and will continue working.
+- If `update-database-all` reports “no migration files found” for a context, run `get-migrations <ContextName>`. If empty, create a migration with `add-migration <Name> <ContextName>` or use `add-migration-all <Name>`.
+