masterrecord 0.3.30 → 0.3.32

package/Entity/entityModelBuilder.js

@@ -46,17 +46,60 @@ class EntityModelBuilder {
             MDB.obj.name = methodName;
             obj[methodName] = MDB.obj;
         }
+
+        // Extract composite indexes from static property (Option A)
+        if (model.compositeIndexes) {
+            obj.__compositeIndexes = this.#normalizeCompositeIndexes(
+                model.compositeIndexes,
+                model.name
+            );
+        } else {
+            obj.__compositeIndexes = [];  // Initialize empty array
+        }
+
         return obj;
     }
 
     static cleanNull(obj) {
-        for (var propName in obj) { 
+        for (var propName in obj) {
           if (obj[propName] === null) {
             delete obj[propName];
           }
         }
     }
 
+    static #normalizeCompositeIndexes(indexes, tableName) {
+        if (!Array.isArray(indexes)) {
+            throw new Error(`compositeIndexes must be an array`);
+        }
+
+        return indexes.map((index, i) => {
+            // Simple array: ['col1', 'col2'] -> auto-generate name
+            if (Array.isArray(index)) {
+                const colNames = index.join('_');
+                return {
+                    columns: index,
+                    name: `idx_${tableName.toLowerCase()}_${colNames}`,
+                    unique: false
+                };
+            }
+
+            // Object: { columns: [...], name?, unique? }
+            if (!index.columns || !Array.isArray(index.columns)) {
+                throw new Error(`Composite index must have 'columns' array`);
+            }
+
+            const name = index.name ||
+                `idx_${tableName.toLowerCase()}_${index.columns.join('_')}`;
+
+            return {
+                columns: index.columns,
+                name: name,
+                unique: index.unique || false
+            };
+        });
+    }
+
 }
 
 module.exports = EntityModelBuilder;

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

@@ -246,6 +246,16 @@ class migrationMySQLQuery {
         return `DROP INDEX \`${indexName}\` ON \`${indexInfo.tableName}\``;
     }
 
+    createCompositeIndex(indexInfo){
+        const columns = indexInfo.columns.map(c => `\`${c}\``).join(', ');
+        const uniqueKeyword = indexInfo.unique ? 'UNIQUE ' : '';
+        return `CREATE ${uniqueKeyword}INDEX \`${indexInfo.indexName}\` ON \`${indexInfo.tableName}\`(${columns})`;
+    }
+
+    dropCompositeIndex(indexInfo){
+        return `DROP INDEX \`${indexInfo.indexName}\` ON \`${indexInfo.tableName}\``;
+    }
+
     /**
      * SEED DATA METHODS
      * Support for inserting seed data during migrations

package/Migrations/migrationPostgresQuery.js

@@ -233,6 +233,16 @@ class migrationPostgresQuery {
         return `DROP INDEX IF EXISTS "${indexName}"`;
     }
 
+    createCompositeIndex(indexInfo){
+        const columns = indexInfo.columns.map(c => `"${c}"`).join(', ');
+        const uniqueKeyword = indexInfo.unique ? 'UNIQUE ' : '';
+        return `CREATE ${uniqueKeyword}INDEX IF NOT EXISTS "${indexInfo.indexName}" ON "${indexInfo.tableName}"(${columns})`;
+    }
+
+    dropCompositeIndex(indexInfo){
+        return `DROP INDEX IF EXISTS "${indexInfo.indexName}"`;
+    }
+
     /**
      * SEED DATA METHODS
      * Support for inserting seed data during migrations

package/Migrations/migrationSQLiteQuery.js

@@ -201,6 +201,16 @@ class migrationSQLiteQuery {
         return `DROP INDEX IF EXISTS ${indexName}`;
     }
 
+    createCompositeIndex(indexInfo){
+        const columns = indexInfo.columns.join(', ');
+        const uniqueKeyword = indexInfo.unique ? 'UNIQUE ' : '';
+        return `CREATE ${uniqueKeyword}INDEX IF NOT EXISTS ${indexInfo.indexName} ON ${indexInfo.tableName}(${columns})`;
+    }
+
+    dropCompositeIndex(indexInfo){
+        return `DROP INDEX IF EXISTS ${indexInfo.indexName}`;
+    }
+
     /**
      * SEED DATA METHODS
      * Support for inserting seed data during migrations

package/Migrations/migrationTemplate.js

@@ -120,6 +120,182 @@ module.exports = ${this.name};
         }
     }
 
+    createCompositeIndex(type, indexInfo){
+        const indexInfoStr = JSON.stringify({
+            tableName: indexInfo.tableName,
+            columns: indexInfo.columns,
+            indexName: indexInfo.indexName,
+            unique: indexInfo.unique
+        });
+
+        if(type === "up"){
+            this.#up += os.EOL + `     this.createCompositeIndex(${indexInfoStr});`
+        }
+        else{
+            this.#down += os.EOL + `     this.dropCompositeIndex(${indexInfoStr});`
+        }
+    }
+
+    dropCompositeIndex(type, indexInfo){
+        const indexInfoStr = JSON.stringify({
+            tableName: indexInfo.tableName,
+            columns: indexInfo.columns,
+            indexName: indexInfo.indexName,
+            unique: indexInfo.unique
+        });
+
+        if(type === "up"){
+            this.#up += os.EOL + `     this.dropCompositeIndex(${indexInfoStr});`
+        }
+        else{
+            this.#down += os.EOL + `     this.createCompositeIndex(${indexInfoStr});`
+        }
+    }
+
+    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;