masterrecord 0.3.31 → 0.3.32

package/Migrations/cli.js

@@ -275,15 +275,17 @@ program.option('-V', 'output the version');
           return;
         }
         var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+        var seedData = contextInstance.__contextSeedData || {};
+        var seedConfig = contextInstance.__contextSeedConfig || {};
 
         // Skip if no changes between snapshot schema and current entities
-        const has = migration.hasChanges(contextSnapshot.schema || [], cleanEntities || []);
+        const has = migration.hasChanges(contextSnapshot.schema || [], cleanEntities || [], seedData);
         if(!has){
           console.log(`No changes detected for ${path.basename(contextAbs)}. Skipping.`);
           return;
         }
 
-        var newEntity = migration.template(name, contextSnapshot.schema, cleanEntities);
+        var newEntity = migration.template(name, contextSnapshot.schema, cleanEntities, seedData, seedConfig);
         if(!fs.existsSync(migBase)){
           try{ fs.mkdirSync(migBase, { recursive: true }); }catch(_){ /* ignore */ }
         }
@@ -465,6 +467,7 @@ program.option('-V', 'output the version');
            executedLocation : executedLocation,
            context : contextInstance,
            contextEntities : cleanEntities,
+           contextSeedData: contextInstance.__contextSeedData || {},
            contextFileName: contextFileName
          }
 
@@ -582,6 +585,8 @@ program.option('-V', 'output the version');
          executedLocation : executedLocation,
          context : contextInstance,
          contextEntities : cleanEntities,
+         contextSeedData: contextInstance.__contextSeedData || {},
+         contextSeedConfig: contextInstance.__contextSeedConfig || {},
          contextFileName: contextFileName
        }
        migration.createSnapShot(snap);
@@ -832,6 +837,8 @@ program.option('-V', 'output the version');
         executedLocation : executedLocation,
         context : contextInstance,
         contextEntities : cleanEntities,
+        contextSeedData: contextInstance.__contextSeedData || {},
+        contextSeedConfig: contextInstance.__contextSeedConfig || {},
         contextFileName: path.basename(snapshotFile).replace('_contextSnapShot.json','')
       }
       migration.createSnapShot(snap);
@@ -887,13 +894,15 @@ program.option('-V', 'output the version');
           }
           var migration = new Migration();
           var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+          var seedData = contextInstance.__contextSeedData || {};
+          var seedConfig = contextInstance.__contextSeedConfig || {};
           // If no changes, skip with message
-          const has = migration.hasChanges(cs.schema || [], cleanEntities || []);
+          const has = migration.hasChanges(cs.schema || [], cleanEntities || [], seedData);
           if(!has){
             console.log(`No changes detected for ${path.basename(contextAbs)}. Skipping.`);
             continue;
           }
-          var newEntity = migration.template(name, cs.schema, cleanEntities);
+          var newEntity = migration.template(name, cs.schema, cleanEntities, seedData, seedConfig);
           if(!fs.existsSync(migBase)){
             try{ fs.mkdirSync(migBase, { recursive: true }); }catch(_){ /* ignore */ }
           }
@@ -1010,6 +1019,8 @@ program.option('-V', 'output the version');
             executedLocation : executedLocation,
             context : contextInstance,
             contextEntities : cleanEntities,
+            contextSeedData: contextInstance.__contextSeedData || {},
+            contextSeedConfig: contextInstance.__contextSeedConfig || {},
             contextFileName: entry.ctxName
           }
           migration.createSnapShot(snap);
@@ -1072,6 +1083,8 @@ program.option('-V', 'output the version');
             file : abs,
             executedLocation : executedLocation,
             contextEntities : [],
+            contextSeedData: {},
+            contextSeedConfig: {},
             contextFileName: key
           };
           migration.createSnapShot(snap);

package/Migrations/dependencyGraph.js

@@ -0,0 +1,108 @@
+/**
+ * Dependency graph for topological sorting of seed data
+ * Uses Kahn's algorithm to order tables by foreign key dependencies
+ */
+class DependencyGraph {
+    constructor(entities) {
+        this.entities = entities;
+        this.graph = new Map();    // adjacency list: parent -> [children]
+        this.inDegree = new Map(); // in-degree for each table (number of dependencies)
+    }
+
+    /**
+     * Build dependency graph from entity relationships
+     * Tables with belongsTo relationships depend on their foreign tables
+     */
+    buildFromEntities() {
+        // Initialize graph structure for all entities
+        this.entities.forEach(entity => {
+            const tableName = entity.__name;
+            if (!tableName) return;
+
+            this.graph.set(tableName, []);
+            this.inDegree.set(tableName, 0);
+        });
+
+        // Build edges from belongsTo relationships
+        this.entities.forEach(entity => {
+            const tableName = entity.__name;
+            if (!tableName) return;
+
+            // Find belongsTo relationships (dependencies)
+            Object.keys(entity).forEach(key => {
+                const field = entity[key];
+
+                // Check if this is a belongsTo relationship with a foreign table
+                if (field && typeof field === 'object' &&
+                    field.relationshipType === 'belongsTo' &&
+                    field.foreignTable) {
+
+                    const foreignTable = field.foreignTable;
+
+                    // Ensure foreign table exists in graph
+                    if (!this.graph.has(foreignTable)) {
+                        this.graph.set(foreignTable, []);
+                        this.inDegree.set(foreignTable, 0);
+                    }
+
+                    // Add edge: foreignTable -> tableName (tableName depends on foreignTable)
+                    this.graph.get(foreignTable).push(tableName);
+                    this.inDegree.set(tableName, this.inDegree.get(tableName) + 1);
+                }
+            });
+        });
+    }
+
+    /**
+     * Perform topological sort using Kahn's algorithm
+     * @returns {Array<string>} Ordered list of table names
+     * @throws {Error} If circular dependency detected
+     */
+    topologicalSort() {
+        const result = [];
+        const queue = [];
+        const inDegreeCopy = new Map(this.inDegree);
+
+        // Start with nodes that have no dependencies (in-degree = 0)
+        for (const [node, degree] of inDegreeCopy.entries()) {
+            if (degree === 0) {
+                queue.push(node);
+            }
+        }
+
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+
+            // Process all neighbors (tables that depend on current)
+            const neighbors = this.graph.get(current) || [];
+            neighbors.forEach(neighbor => {
+                inDegreeCopy.set(neighbor, inDegreeCopy.get(neighbor) - 1);
+                if (inDegreeCopy.get(neighbor) === 0) {
+                    queue.push(neighbor);
+                }
+            });
+        }
+
+        // Detect cycles: if we couldn't visit all nodes, there's a cycle
+        if (result.length !== this.inDegree.size) {
+            const unvisited = Array.from(this.inDegree.keys()).filter(k => !result.includes(k));
+            throw new Error(`Circular dependency detected in tables: ${unvisited.join(' <-> ')}`);
+        }
+
+        return result;
+    }
+
+    /**
+     * Get topologically sorted list filtered to only tables with seed data
+     * @param {Object} seedData - Object with table names as keys
+     * @returns {Array<string>} Ordered list of table names that have seed data
+     */
+    filterToSeededTables(seedData) {
+        const sorted = this.topologicalSort();
+        const seededTables = Object.keys(seedData);
+        return sorted.filter(table => seededTables.includes(table));
+    }
+}
+
+module.exports = DependencyGraph;

package/Migrations/migrationTemplate.js

@@ -152,6 +152,150 @@ module.exports = ${this.name};
         }
     }
 
+    seedData(type, tableName, records, currentEnv = 'development'){
+        if(!records || records.length === 0) return;
+
+        if(type === "up"){
+            // Filter records by environment first
+            const filteredRecords = records.filter(record => {
+                const envCondition = record.__seedEnv;
+                if (envCondition && envCondition.strategy === 'generation-time') {
+                    return envCondition.conditions.includes(currentEnv);
+                }
+                return true; // No environment condition, include record
+            });
+
+            if (filteredRecords.length === 0) return;
+
+            // Check if all records are factory-generated
+            const allGenerated = filteredRecords.every(r => r.__seedMeta?.generated);
+
+            // Use optimized loop syntax for bulk factory data (10+ records)
+            if (allGenerated && filteredRecords.length >= 10) {
+                this.#up += os.EOL + `     const factoryRecords = [`;
+
+                filteredRecords.forEach((record, i) => {
+                    const cleanRecord = { ...record };
+                    delete cleanRecord.__rollback;
+                    delete cleanRecord.__seedEnv;
+                    delete cleanRecord.__seedStrategy;
+                    delete cleanRecord.__seedMeta;
+
+                    const recordStr = JSON.stringify(cleanRecord);
+                    this.#up += os.EOL + `         ${recordStr}${i < filteredRecords.length - 1 ? ',' : ''}`;
+                });
+
+                this.#up += os.EOL + `     ];`;
+                this.#up += os.EOL + `     for (const record of factoryRecords) {`;
+                this.#up += os.EOL + `         await table.${tableName}.create(record);`;
+                this.#up += os.EOL + `     }`;
+            } else {
+                // Standard individual inserts for non-factory or small batches
+                filteredRecords.forEach(record => {
+                    const strategy = record.__seedStrategy;
+
+                    // Clean up metadata before generating migration code
+                    const cleanRecord = { ...record };
+                    delete cleanRecord.__rollback;
+                    delete cleanRecord.__seedEnv;
+                    delete cleanRecord.__seedStrategy;
+                    delete cleanRecord.__seedMeta;
+
+                    // Handle upsert strategy
+                    if (strategy && strategy.type === 'upsert') {
+                        this._generateUpsert(tableName, cleanRecord, strategy);
+                    } else {
+                        // Standard insert
+                        const recordStr = JSON.stringify(cleanRecord);
+
+                        // Check if record is too long for single line (> 80 chars)
+                        if (recordStr.length > 80) {
+                            // Multi-line format with proper indentation
+                            const formattedRecord = JSON.stringify(cleanRecord, null, 12)
+                                .split('\n')
+                                .join(os.EOL + '            ');
+                            this.#up += os.EOL + `     await table.${tableName}.create(${formattedRecord});`;
+                        } else {
+                            // Single-line format
+                            this.#up += os.EOL + `     await table.${tableName}.create(${recordStr});`;
+                        }
+                    }
+                });
+            }
+        }
+    }
+
+    _generateUpsert(tableName, cleanRecord, strategy) {
+        const conflictKey = strategy.conflictKey === 'primaryKey'
+            ? (cleanRecord.id !== undefined ? 'id' : Object.keys(cleanRecord)[0])
+            : strategy.conflictKey;
+
+        const conflictValue = cleanRecord[conflictKey];
+        if (conflictValue === undefined) {
+            throw new Error(`Upsert requires a value for conflict key: ${conflictKey}`);
+        }
+
+        this.#up += os.EOL + `     {`;
+        this.#up += os.EOL + `         const existing = await table.${tableName}.where(r => r.${conflictKey} == ${JSON.stringify(conflictValue)}).single();`;
+        this.#up += os.EOL + `         if (existing) {`;
+
+        // Update logic
+        if (strategy.updateFields && Array.isArray(strategy.updateFields)) {
+            strategy.updateFields.forEach(field => {
+                if (cleanRecord[field] !== undefined) {
+                    this.#up += os.EOL + `             existing.${field} = ${JSON.stringify(cleanRecord[field])};`;
+                }
+            });
+        } else {
+            // Update all fields except conflict key
+            Object.keys(cleanRecord).forEach(field => {
+                if (field !== conflictKey) {
+                    this.#up += os.EOL + `             existing.${field} = ${JSON.stringify(cleanRecord[field])};`;
+                }
+            });
+        }
+
+        this.#up += os.EOL + `             await existing.save();`;
+        this.#up += os.EOL + `         } else {`;
+        this.#up += os.EOL + `             await table.${tableName}.create(${JSON.stringify(cleanRecord)});`;
+        this.#up += os.EOL + `         }`;
+        this.#up += os.EOL + `     }`;
+    }
+
+    seedDataDown(type, tableName, records, config){
+        if(type !== "down" || !config || !config.generateDownMigrations) return;
+        if(!records || records.length === 0) return;
+
+        // Reverse order for safe FK deletion (children before parents)
+        const reversed = [...records].reverse();
+
+        reversed.forEach(record => {
+            const rollback = record.__rollback;
+            if (!rollback || !rollback.value) {
+                // Skip if no rollback metadata (e.g., no primary key specified)
+                return;
+            }
+
+            const pkValue = rollback.value;
+            const pkKey = rollback.key || 'id';
+
+            // Generate delete code with error handling
+            this.#down += os.EOL + `     try {`;
+            this.#down += os.EOL + `         const record = await table.${tableName}.findById(${JSON.stringify(pkValue)});`;
+            this.#down += os.EOL + `         if (record) await record.delete();`;
+            this.#down += os.EOL + `     } catch (e) {`;
+
+            if (config.onRollbackError === 'throw') {
+                this.#down += os.EOL + `         throw new Error('Seed rollback failed: ${tableName} id=${pkValue} - ' + e.message);`;
+            } else if (config.onRollbackError === 'warn') {
+                this.#down += os.EOL + `         console.warn('Seed rollback: ${tableName} id=${pkValue} not found or error:', e.message);`;
+            }
+            // else ignore (onRollbackError === 'ignore')
+
+            this.#down += os.EOL + `     }`;
+        });
+    }
+
 }
 
 module.exports = MigrationTemplate;

package/Migrations/migrations.js

@@ -28,7 +28,8 @@ class Migrations{
                         newIndexes : [],
                         deletedIndexes : [],
                         newCompositeIndexes : [],
-                        deletedCompositeIndexes : []
+                        deletedCompositeIndexes : [],
+                        newSeedData : []
                     }
                     tables.push(table);
                 });
@@ -46,7 +47,8 @@ class Migrations{
                         newIndexes : [],
                         deletedIndexes : [],
                         newCompositeIndexes : [],
-                        deletedCompositeIndexes : []
+                        deletedCompositeIndexes : [],
+                        newSeedData : []
                     }
 
                     oldSchema.forEach(function (oldItem, index) {
@@ -161,7 +163,7 @@ class Migrations{
     }
 
     // build table to build new migration snapshot
-    #buildMigrationObject(oldSchema, newSchema){
+    #buildMigrationObject(oldSchema, newSchema, newSeedData = {}){
 
         var tables = this.#organizeSchemaByTables(oldSchema, newSchema);
 
@@ -173,6 +175,7 @@ class Migrations{
         tables = this.#findDeletedIndexes(tables);
         tables = this.#findNewCompositeIndexes(tables);
         tables = this.#findDeletedCompositeIndexes(tables);
+        tables = this.#findNewSeedData(tables, newSeedData);
         return tables;
     }
 
@@ -325,6 +328,17 @@ class Migrations{
         return tables;
     }
 
+    #findNewSeedData(tables, newSeedData) {
+        // newSeedData is from schema snapshot: { tableName: [records] }
+        tables.forEach(function(item) {
+            const tableSeedData = newSeedData[item.name];
+            if (tableSeedData && tableSeedData.length > 0) {
+                item.newSeedData = tableSeedData;
+            }
+        });
+        return tables;
+    }
+
 
 
     findContextFile(executedLocation, contextFileName){
@@ -397,11 +411,18 @@ class Migrations{
         const relMigrationFolder = '.'; // the snapshot sits inside migrationsDirectory
         const relSnapshotLocation = path.basename(snapshotPath);
 
+        // Order seed data by dependencies if context instance is available
+        const orderedSeedData = snap.context && snap.context.getOrderedSeedData
+            ? snap.context.getOrderedSeedData()
+            : snap.contextSeedData || {};
+
         const content = {
             contextLocation: relContextLocation,
             migrationFolder: relMigrationFolder,
             snapShotLocation: relSnapshotLocation,
-            schema : snap.contextEntities
+            schema : snap.contextEntities,
+            seedData: orderedSeedData,
+            seedConfig: snap.contextSeedConfig || {}
         };
 
         const jsonContent = JSON.stringify(content, null, 2);
@@ -455,8 +476,8 @@ class Migrations{
     }
 
     // Returns true if there are any changes between old and new schema
-    hasChanges(oldSchema, newSchema){
-        const tables = this.#buildMigrationObject(oldSchema, newSchema);
+    hasChanges(oldSchema, newSchema, newSeedData = {}){
+        const tables = this.#buildMigrationObject(oldSchema, newSchema, newSeedData);
         for(const t of tables){
             if(!t) continue;
             if((t.newTables && t.newTables.length) ||
@@ -467,6 +488,7 @@ class Migrations{
                (t.deletedIndexes && t.deletedIndexes.length) ||
                (t.newCompositeIndexes && t.newCompositeIndexes.length) ||
                (t.deletedCompositeIndexes && t.deletedCompositeIndexes.length) ||
+               (t.newSeedData && t.newSeedData.length) ||
                (t.old === null) || (t.new === null)){
                 return true;
             }
@@ -474,16 +496,20 @@ class Migrations{
         return false;
     }
 
-    template(name, oldSchema, newSchema){
+    template(name, oldSchema, newSchema, newSeedData = {}, seedConfig = {}, currentEnv = null){
         var MT = new MigrationTemplate(name);
-        var tables = this.#buildMigrationObject(oldSchema, newSchema);
-    
+        // Determine current environment if not provided
+        if (!currentEnv) {
+            currentEnv = process.env.NODE_ENV || process.env.master || 'development';
+        }
+        var tables = this.#buildMigrationObject(oldSchema, newSchema, newSeedData);
+
         tables.forEach(function (item, index) {
             if(item.old === null){
                 MT.createTable("up", column, item.name);
                 MT.dropTable("down", column, item.name);
             }
-            
+
             if(item.new === null){
                 MT.dropTable("up", column, item.name);
                 MT.createTable("down", column, item.name);
@@ -529,6 +555,12 @@ class Migrations{
                 MT.dropCompositeIndex("up", indexInfo);
             });
 
+            // Generate seed data code
+            if (item.newSeedData && item.newSeedData.length > 0) {
+                MT.seedData("up", item.name, item.newSeedData, currentEnv);
+                MT.seedDataDown("down", item.name, item.newSeedData, seedConfig);
+            }
+
         });
 
        return MT.get();