masterrecord 0.3.32 → 0.3.34

package/.claude/settings.local.json

@@ -58,7 +58,9 @@
       "Bash(wc:*)",
       "Bash(npm link)",
       "Bash(npm link:*)",
-      "Bash(1)"
+      "Bash(1)",
+      "Bash(masterrecord update-database:*)",
+      "Bash(npx mocha:*)"
     ],
     "deny": [],
     "ask": []

package/.github/FUTURE_IMPROVEMENTS.md

@@ -0,0 +1,138 @@
+# Future Improvements for MasterRecord
+
+## Metadata Property Handling
+
+### Context
+The `.index()` bug fix (commit 6e774a7) introduced a blacklist approach to skip metadata properties during schema processing. While this solves the immediate problem, there are architectural improvements to consider for future versions.
+
+### Current Solution (v0.3.33)
+```javascript
+for (var key in table) {
+    // Skip metadata properties (indexes, __compositeIndexes, __name, etc.)
+    if(key === 'indexes' || key.startsWith('__')){
+        continue;
+    }
+    // ... process columns
+}
+```
+
+**Status:** ✅ Shipped - Works well, well-tested, solves the problem
+
+### Future Considerations
+
+#### 1. Document the Metadata Convention
+**Priority:** Medium
+**Effort:** Low
+
+Add clear documentation explaining that properties starting with `__` are reserved for internal metadata and will be skipped during schema processing. This should be documented in:
+- README.md (Entity Model section)
+- Code comments in `entityModel.js`
+- Migration guide if breaking changes are made
+
+**Example documentation:**
+```markdown
+## Reserved Property Names
+- Properties starting with `__` (double underscore) are reserved for internal metadata
+- `indexes` property is reserved for index definitions
+- These properties are automatically skipped during table creation
+```
+
+#### 2. Whitelist Approach (Long-term)
+**Priority:** Low
+**Effort:** Medium
+**Breaking Change:** Potentially
+
+Instead of blacklisting specific properties, consider only processing properties that are actually column definitions.
+
+**Pros:**
+- More robust if new metadata properties are added
+- Explicit about what gets processed
+- Self-documenting code
+
+**Cons:**
+- Requires careful design to not break existing functionality
+- More complex validation logic
+- Could impact performance
+
+**Example approach:**
+```javascript
+for (var key in table) {
+    if(typeof table[key] !== "object") continue;
+
+    var col = table[key];
+
+    // Only process objects that have column-like properties
+    if(!col.name || !col.type) continue;
+
+    // Skip relationship types
+    if(col.type === 'hasOne' || col.type === 'hasMany' || col.type === 'hasManyThrough'){
+        continue;
+    }
+
+    queryVar += `${this.#columnMapping(col)}, `;
+}
+```
+
+#### 3. Use JavaScript Symbols for Metadata (v1.0+)
+**Priority:** Low
+**Effort:** High
+**Breaking Change:** Yes
+
+For future major versions, consider using JavaScript Symbols for all internal metadata. Symbols don't appear in `for...in` loops or `Object.keys()`, eliminating this entire class of bugs.
+
+**Benefits:**
+- Metadata becomes truly invisible to iteration
+- No special-case filtering needed
+- Cleaner separation of concerns
+- More idiomatic JavaScript
+
+**Migration path:**
+```javascript
+// Current (v0.x)
+table.__name = 'Users';
+table.indexes = ['idx_name'];
+
+// Future (v1.0+)
+const META_NAME = Symbol('name');
+const META_INDEXES = Symbol('indexes');
+
+table[META_NAME] = 'Users';
+table[META_INDEXES] = ['idx_name'];
+```
+
+**Challenges:**
+- Requires refactoring all metadata access
+- Breaks existing code that accesses `__name`, `__compositeIndexes`, etc.
+- Would need comprehensive migration guide
+- Testing burden is significant
+
+**When to consider:**
+- During a major version bump (v1.0)
+- When other breaking changes are planned
+- After gathering user feedback on current metadata usage patterns
+
+---
+
+## Implementation Notes
+
+### Current Fix is Good to Ship ✅
+The blacklist approach (`indexes` and `__*` properties) is:
+- Practical and solves the immediate problem
+- Well-tested (5 comprehensive tests)
+- Easy to understand and maintain
+- Not over-engineered
+
+### Recommendation
+1. **Ship the current fix** (already committed)
+2. **Add documentation** about the `__` convention in next minor release
+3. **Track whitelist approach** as a potential v0.4+ enhancement
+4. **Consider Symbols** only for v1.0 major version
+
+---
+
+## Related Issues
+- Index bug fix: commit 6e774a7
+- Test suite: `test/index-bug-fix-test.js`
+
+## Feedback Credit
+These suggestions came from code review feedback on the index bug fix implementation.

package/Entity/entityModel.js

@@ -1,5 +1,6 @@
 /*
 
+Supported column types:
 :binary
 :boolean
 :date
@@ -15,6 +16,11 @@
 :time
 :timestamp
 
+Reserved Property Names:
+- Properties starting with '__' (double underscore) are reserved for internal metadata
+- 'indexes' property is reserved for index definitions
+- These properties are automatically skipped during table creation in migration queries
+
 */
 
 // version 0.0.5
@@ -115,6 +121,17 @@ class EntityModel {
 
     }
 
+    /**
+     * Adds an index to this column definition.
+     *
+     * Note: The 'indexes' property is metadata and will be automatically skipped
+     * during table creation. Properties starting with '__' are also reserved for
+     * internal metadata and filtered during schema processing.
+     *
+     * @param {string} indexName - Optional custom name for the index. If not provided,
+     *                              a default name will be generated.
+     * @returns {EntityModel} Returns this for method chaining
+     */
     index(indexName){
         if(!this.obj.indexes){
             this.obj.indexes = [];

package/Migrations/migrationMySQLQuery.js

@@ -193,10 +193,22 @@ class migrationMySQLQuery {
         var queryVar = "";
         //console.log("Dsfdsfdsf---------", table)
         for (var key in table) {
+            // Skip metadata properties (indexes, __compositeIndexes, __name, etc.)
+            if(key === 'indexes' || key.startsWith('__')){
+                continue;
+            }
+
             if(typeof table[key] === "object"){
+                var col = table[key];
+
+                if(col.type !== "hasOne" && col.type  !== "hasMany" && col.type  !== "hasManyThrough"){
+                    // Whitelist: Only process objects that look like column definitions
+                    // Valid columns must have 'name' and 'type' properties
+                    if(!col.name || !col.type){
+                        continue;
+                    }
 
-                if(table[key].type !== "hasOne" && table[key].type  !== "hasMany" && table[key].type  !== "hasManyThrough"){
-                    queryVar += `${this.#columnMapping(table[key])}, `;
+                    queryVar += `${this.#columnMapping(col)}, `;
                 }
             }
         }

package/Migrations/migrationPostgresQuery.js

@@ -196,9 +196,22 @@ class migrationPostgresQuery {
         var queryVar = "";
 
         for (var key in table) {
+            // Skip metadata properties (indexes, __compositeIndexes, __name, etc.)
+            if(key === 'indexes' || key.startsWith('__')){
+                continue;
+            }
+
             if(typeof table[key] === "object"){
-                if(table[key].type !== "hasOne" && table[key].type !== "hasMany" && table[key].type !== "hasManyThrough"){
-                    queryVar += `${this.#columnMapping(table[key])}, `;
+                var col = table[key];
+
+                if(col.type !== "hasOne" && col.type !== "hasMany" && col.type !== "hasManyThrough"){
+                    // Whitelist: Only process objects that look like column definitions
+                    // Valid columns must have 'name' and 'type' properties
+                    if(!col.name || !col.type){
+                        continue;
+                    }
+
+                    queryVar += `${this.#columnMapping(col)}, `;
                 }
             }
         }

package/Migrations/migrationSQLiteQuery.js

@@ -147,16 +147,28 @@ class migrationSQLiteQuery {
     createTable(table){
         var queryVar = "";
         for (var key in table) {
+            // Skip metadata properties (indexes, __compositeIndexes, __name, etc.)
+            if(key === 'indexes' || key.startsWith('__')){
+                continue;
+            }
+
             if(typeof table[key] === "object"){
                 var col = table[key];
                 // Skip relationship-only fields
                 if(col.type === 'hasOne' || col.type === 'hasMany' || col.type === 'hasManyThrough'){
                     continue;
                 }
+
+                // Whitelist: Only process objects that look like column definitions
+                // Valid columns must have 'name' and 'type' properties
+                if(!col.name || !col.type){
+                    continue;
+                }
+
                 queryVar += `${this.#columnMapping(col)}, `;
             }
         }
-    
+
         return `CREATE TABLE IF NOT EXISTS ${table.__name} (${queryVar.replace(/,\s*$/, "")});`;
 
             /*

package/Migrations/migrationTemplate.js

@@ -94,10 +94,10 @@ module.exports = ${this.name};
         });
 
         if(type === "up"){
-            this.#up += os.EOL + `     this.createIndex(${indexInfoStr});`
+            this.#up += os.EOL + `     await this.createIndex(${indexInfoStr});`
         }
         else{
-            this.#down += os.EOL + `     this.dropIndex(${indexInfoStr});`
+            this.#down += os.EOL + `     await this.dropIndex(${indexInfoStr});`
         }
     }
 
@@ -113,10 +113,10 @@ module.exports = ${this.name};
         });
 
         if(type === "up"){
-            this.#up += os.EOL + `     this.dropIndex(${indexInfoStr});`
+            this.#up += os.EOL + `     await this.dropIndex(${indexInfoStr});`
         }
         else{
-            this.#down += os.EOL + `     this.createIndex(${indexInfoStr});`
+            this.#down += os.EOL + `     await this.createIndex(${indexInfoStr});`
         }
     }
 
@@ -129,10 +129,10 @@ module.exports = ${this.name};
         });
 
         if(type === "up"){
-            this.#up += os.EOL + `     this.createCompositeIndex(${indexInfoStr});`
+            this.#up += os.EOL + `     await this.createCompositeIndex(${indexInfoStr});`
         }
         else{
-            this.#down += os.EOL + `     this.dropCompositeIndex(${indexInfoStr});`
+            this.#down += os.EOL + `     await this.dropCompositeIndex(${indexInfoStr});`
         }
     }
 
@@ -145,10 +145,10 @@ module.exports = ${this.name};
         });
 
         if(type === "up"){
-            this.#up += os.EOL + `     this.dropCompositeIndex(${indexInfoStr});`
+            this.#up += os.EOL + `     await this.dropCompositeIndex(${indexInfoStr});`
         }
         else{
-            this.#down += os.EOL + `     this.createCompositeIndex(${indexInfoStr});`
+            this.#down += os.EOL + `     await this.createCompositeIndex(${indexInfoStr});`
         }
     }
 
@@ -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 + `         await table.${tableName}.create(record);`;
+                this.#up += os.EOL + `         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 + `     await table.${tableName}.create(${formattedRecord});`;
+                            this.#up += os.EOL + `     this.seed('${tableName}', ${formattedRecord});`;
                         } else {
                             // Single-line format
-                            this.#up += os.EOL + `     await table.${tableName}.create(${recordStr});`;
+                            this.#up += os.EOL + `     this.seed('${tableName}', ${recordStr});`;
                         }
                     }
                 });
@@ -236,7 +236,7 @@ module.exports = ${this.name};
         }
 
         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 + `         const existing = await this.context.${tableName}.where(r => r.${conflictKey} == ${JSON.stringify(conflictValue)}).single();`;
         this.#up += os.EOL + `         if (existing) {`;
 
         // Update logic
@@ -257,7 +257,7 @@ module.exports = ${this.name};
 
         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.seed('${tableName}', ${JSON.stringify(cleanRecord)});`;
         this.#up += os.EOL + `         }`;
         this.#up += os.EOL + `     }`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.32",
+  "version": "0.3.34",
   "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": {

package/readme.md

@@ -3367,11 +3367,48 @@ if (ids.length > 0) {
 user.name = null;  // Error if name is { nullable: false }
 ```
 
+## Changelog
+
+### Version 0.3.34 (2026-02-05)
+
+#### Bug Fixes
+- **Fixed**: Seed API migration generation - resolved `table.EntityName.create is not a function` error
+  - Migrations now use `this.seed('TableName', data)` instead of `table.TableName.create(data)`
+  - Ensures compatibility with the migration schema base class
+- **Fixed**: Eliminated duplicate table creation statements in generated migrations
+- **Fixed**: Eliminated duplicate seed insertion statements in generated migrations
+- **Fixed**: Duplicate index creation when using `.index()` in column definitions
+  - Index operations now properly deduplicated during migration generation
+- **Fixed**: Missing `await` keywords on `createIndex()`, `dropIndex()`, `createCompositeIndex()`, and `dropCompositeIndex()` calls in migrations
+  - All async index operations now properly awaited for consistency
+
+#### Improvements
+- **Enhanced**: Query builders now use whitelist validation for column definitions
+  - Validates that objects have both `name` and `type` properties before processing as columns
+  - More robust metadata property filtering in schema processing
+  - Combines blacklist (skip `indexes`, `__*` prefixed) with whitelist (require `name` and `type`) for comprehensive validation
+- **Documentation**: Enhanced migration generation documentation
+- **Testing**: Added comprehensive test suite for v0.3.34 bug fixes
+  - Tests whitelist validation across all three database backends
+  - Tests async/await consistency in index operations
+  - Tests seed API correctness and deduplication
+
+#### Technical Details
+- Query builders (SQLite, MySQL, PostgreSQL) validate column definitions have required `name` and `type` properties
+- Migration template generates proper ORM API calls for seed data using `this.seed()` method
+- Index deduplication logic prevents duplicate CREATE INDEX statements
+- All migration operations consistently use `await` for async consistency
+
+#### Migration Notes
+- Existing migrations generated with older versions will continue to work
+- New migrations will use the corrected seed API syntax
+- If you have migrations with `table.EntityName.create()` that haven't been run, regenerate them with this version
+
 ## Version Compatibility
 
 | Component     | Version       | Notes                                    |
 |---------------|---------------|------------------------------------------|
-| MasterRecord  | 0.3.13        | Current version with PostgreSQL support  |
+| MasterRecord  | 0.3.34        | Current version with bug fixes and improvements |
 | Node.js       | 14+           | Async/await support required             |
 | PostgreSQL    | 9.6+ (12+)    | Tested with 12, 13, 14, 15, 16          |
 | MySQL         | 5.7+ (8.0+)   | Tested with 8.0+                        |

package/test/index-bug-fix-test.js

@@ -0,0 +1,188 @@
+/**
+ * Test: Index Bug Fix - createTable should not generate "undefined undefined NOT NULL"
+ *
+ * Verifies that .index() method doesn't cause malformed column definitions in CREATE TABLE statements
+ */
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║      Index Bug Fix Test - createTable() Method                ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+const MigrationSQLiteQuery = require('../Migrations/migrationSQLiteQuery.js');
+const MigrationMySQLQuery = require('../Migrations/migrationMySQLQuery.js');
+const MigrationPostgresQuery = require('../Migrations/migrationPostgresQuery.js');
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, message) {
+    if (!condition) {
+        console.log(`❌ FAIL: ${message}`);
+        failed++;
+        return false;
+    }
+    return true;
+}
+
+function test(description, fn) {
+    try {
+        fn();
+        console.log(`✓ ${description}`);
+        passed++;
+    } catch (error) {
+        console.log(`✗ ${description}`);
+        console.log(`  Error: ${error.message}`);
+        failed++;
+    }
+}
+
+// Mock table object with indexes property (simulates what EntityModel creates)
+const mockTable = {
+    __name: 'TestTable',
+    id: {
+        name: 'id',
+        type: 'integer',
+        nullable: false,
+        primary: true,
+        autoIncrement: true
+    },
+    organization_id: {
+        name: 'organization_id',
+        type: 'integer',
+        nullable: false,
+        indexes: ['idx_org']  // This property on the column caused the original bug
+    },
+    name: {
+        name: 'name',
+        type: 'string',
+        nullable: false
+    },
+    // This is the problematic property that was being treated as a column
+    indexes: ['idx_org']
+};
+
+console.log("Testing SQLite Query Builder...\n");
+
+test('SQLite createTable should skip indexes property', () => {
+    const sqliteQuery = new MigrationSQLiteQuery();
+    const sql = sqliteQuery.createTable(mockTable);
+
+    assert(!sql.includes('undefined undefined'),
+        `SQL should not contain "undefined undefined" but got: ${sql}`);
+    assert(sql.includes('id'), 'Should include id column');
+    assert(sql.includes('organization_id'), 'Should include organization_id column');
+    assert(sql.includes('name'), 'Should include name column');
+    assert(sql.startsWith('CREATE TABLE IF NOT EXISTS TestTable'),
+        'Should start with CREATE TABLE');
+
+    console.log(`    Generated SQL: ${sql}\n`);
+});
+
+console.log("Testing MySQL Query Builder...\n");
+
+test('MySQL createTable should skip indexes property', () => {
+    const mysqlQuery = new MigrationMySQLQuery();
+    const sql = mysqlQuery.createTable(mockTable);
+
+    assert(!sql.includes('undefined undefined'),
+        `SQL should not contain "undefined undefined" but got: ${sql}`);
+    assert(sql.includes('id'), 'Should include id column');
+    assert(sql.includes('organization_id'), 'Should include organization_id column');
+    assert(sql.includes('name'), 'Should include name column');
+    assert(sql.startsWith('CREATE TABLE IF NOT EXISTS `TestTable`'),
+        'Should start with CREATE TABLE');
+
+    console.log(`    Generated SQL: ${sql}\n`);
+});
+
+console.log("Testing PostgreSQL Query Builder...\n");
+
+test('PostgreSQL createTable should skip indexes property', () => {
+    const postgresQuery = new MigrationPostgresQuery();
+    const sql = postgresQuery.createTable(mockTable);
+
+    assert(!sql.includes('undefined undefined'),
+        `SQL should not contain "undefined undefined" but got: ${sql}`);
+    assert(sql.includes('id'), 'Should include id column');
+    assert(sql.includes('organization_id'), 'Should include organization_id column');
+    assert(sql.includes('name'), 'Should include name column');
+    assert(sql.startsWith('CREATE TABLE IF NOT EXISTS "TestTable"'),
+        'Should start with CREATE TABLE');
+
+    console.log(`    Generated SQL: ${sql}\n`);
+});
+
+console.log("Testing metadata properties filtering...\n");
+
+test('Should skip __compositeIndexes and other __ properties', () => {
+    const tableWithMetadata = {
+        ...mockTable,
+        __compositeIndexes: [['col1', 'col2']],
+        __someOtherMetadata: 'value'
+    };
+
+    const sqliteQuery = new MigrationSQLiteQuery();
+    const sql = sqliteQuery.createTable(tableWithMetadata);
+
+    assert(!sql.includes('undefined undefined'),
+        `SQL should not contain "undefined undefined" but got: ${sql}`);
+
+    const columnCount = (sql.match(/,/g) || []).length + 1;
+    assert(columnCount === 3, `Should have exactly 3 columns (id, organization_id, name), got ${columnCount}`);
+});
+
+console.log("Testing relationships filtering...\n");
+
+test('Should handle table with relationships correctly', () => {
+    const tableWithRelations = {
+        __name: 'User',
+        id: {
+            name: 'id',
+            type: 'integer',
+            nullable: false,
+            primary: true
+        },
+        name: {
+            name: 'name',
+            type: 'string',
+            nullable: false
+        },
+        posts: {
+            name: 'posts',
+            type: 'hasMany',
+            target: 'Post'
+        },
+        profile: {
+            name: 'profile',
+            type: 'hasOne',
+            target: 'Profile'
+        },
+        indexes: ['idx_user_name']
+    };
+
+    const sqliteQuery = new MigrationSQLiteQuery();
+    const sql = sqliteQuery.createTable(tableWithRelations);
+
+    assert(!sql.includes('hasMany'), 'Should not include hasMany');
+    assert(!sql.includes('hasOne'), 'Should not include hasOne');
+    assert(!sql.includes('undefined undefined'),
+        `SQL should not contain "undefined undefined" but got: ${sql}`);
+    assert(sql.includes('id'), 'Should include id column');
+    assert(sql.includes('name'), 'Should include name column');
+    assert(!sql.includes('posts'), 'Should not include posts relationship');
+    assert(!sql.includes('profile'), 'Should not include profile relationship');
+
+    console.log(`    Generated SQL: ${sql}\n`);
+});
+
+console.log("\n" + "=".repeat(64));
+console.log(`Test Results: ${passed} passed, ${failed} failed`);
+console.log("=".repeat(64));
+
+if (failed > 0) {
+    console.log("\n❌ Some tests failed!");
+    process.exit(1);
+} else {
+    console.log("\n✅ All tests passed!");
+    process.exit(0);
+}

package/test/v0.3.34-bug-fixes-test.js

@@ -0,0 +1,306 @@
+/**
+ * Comprehensive Tests for v0.3.34 Bug Fixes
+ *
+ * Tests:
+ * 1. Whitelist validation in query builders
+ * 2. No duplicate index creation
+ * 3. Seed API migration generation (no duplicates, correct API usage)
+ * 4. All async operations have await keywords
+ */
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║            MasterRecord v0.3.34 Bug Fixes Test                ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+const Migrations = require('../Migrations/migrations');
+const MigrationSQLiteQuery = require('../Migrations/migrationSQLiteQuery');
+const MigrationMySQLQuery = require('../Migrations/migrationMySQLQuery');
+const MigrationPostgresQuery = require('../Migrations/migrationPostgresQuery');
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, message) {
+    if (!condition) {
+        console.log(`❌ FAIL: ${message}`);
+        failed++;
+        return false;
+    }
+    return true;
+}
+
+function test(description, fn) {
+    try {
+        fn();
+        console.log(`✓ ${description}`);
+        passed++;
+    } catch (e) {
+        console.log(`❌ FAIL: ${description}`);
+        console.log(`   Error: ${e.message}`);
+        failed++;
+    }
+}
+
+// =============================================================================
+// Test Suite 1: Whitelist Validation
+// =============================================================================
+console.log("\n📋 Test Suite 1: Whitelist Validation in Query Builders\n");
+
+test('SQLite query builder skips objects without name property', () => {
+    const queryBuilder = new MigrationSQLiteQuery();
+    const table = {
+        __name: 'TestTable',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        weirdMetadata: { foo: 'bar' },  // No name or type - should be skipped
+        name: { name: 'name', type: 'string' }
+    };
+
+    const query = queryBuilder.createTable(table);
+
+    assert(!query.includes('undefined'), 'SQLite: Should not contain undefined');
+    assert(query.includes('id'), 'SQLite: Should contain id column');
+    assert(query.includes('name'), 'SQLite: Should contain name column');
+    assert(!query.includes('foo'), 'SQLite: Should not process metadata without name/type');
+});
+
+test('MySQL query builder skips objects without name property', () => {
+    const queryBuilder = new MigrationMySQLQuery();
+    const table = {
+        __name: 'TestTable',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        weirdMetadata: { foo: 'bar' },
+        name: { name: 'name', type: 'string' }
+    };
+
+    const query = queryBuilder.createTable(table);
+
+    assert(!query.includes('undefined'), 'MySQL: Should not contain undefined');
+    assert(query.includes('id'), 'MySQL: Should contain id column');
+    assert(query.includes('name'), 'MySQL: Should contain name column');
+});
+
+test('PostgreSQL query builder skips objects without name property', () => {
+    const queryBuilder = new MigrationPostgresQuery();
+    const table = {
+        __name: 'TestTable',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        weirdMetadata: { foo: 'bar' },
+        name: { name: 'name', type: 'string' }
+    };
+
+    const query = queryBuilder.createTable(table);
+
+    assert(!query.includes('undefined'), 'PostgreSQL: Should not contain undefined');
+    assert(query.includes('id'), 'PostgreSQL: Should contain id column');
+    assert(query.includes('name'), 'PostgreSQL: Should contain name column');
+});
+
+test('Query builders correctly skip indexes property', () => {
+    const queryBuilder = new MigrationSQLiteQuery();
+    const table = {
+        __name: 'TestTable',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        email: { name: 'email', type: 'string', indexes: ['idx_email'] },
+        indexes: ['some', 'array']  // This is metadata, should be skipped
+    };
+
+    const query = queryBuilder.createTable(table);
+
+    assert(!query.includes('undefined'), 'Should not contain undefined');
+    assert(query.includes('email'), 'Should contain email column');
+    assert(!query.match(/some.*NOT NULL/), 'Should not process indexes array as column');
+});
+
+// =============================================================================
+// Test Suite 2: Index Creation with Await
+// =============================================================================
+console.log("\n📋 Test Suite 2: Index Creation with Await Keywords\n");
+
+test('createIndex generates code with await keyword', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [{
+        __name: 'User',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        email: { name: 'email', type: 'text', indexes: ['idx_user_email'] }
+    }];
+
+    const migrationCode = migrations.template('TestMigration', oldSchema, newSchema);
+
+    const createIndexMatches = migrationCode.match(/await this\.createIndex/g);
+    assert(createIndexMatches && createIndexMatches.length > 0, 'createIndex should have await keyword');
+    assert(!migrationCode.match(/\n\s+this\.createIndex\(/), 'Should not have createIndex without await');
+});
+
+test('createCompositeIndex generates code with await keyword', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [{
+        __name: 'User',
+        id: { name: 'id', type: 'integer' },
+        __compositeIndexes: [{
+            name: 'idx_composite',
+            columns: ['col1', 'col2'],
+            unique: false
+        }]
+    }];
+
+    const migrationCode = migrations.template('TestMigration', oldSchema, newSchema);
+
+    const compositeMatches = migrationCode.match(/await this\.createCompositeIndex/g);
+    assert(compositeMatches && compositeMatches.length > 0, 'createCompositeIndex should have await keyword');
+});
+
+// =============================================================================
+// Test Suite 3: Seed API Migration Generation
+// =============================================================================
+console.log("\n📋 Test Suite 3: Seed API Migration Generation\n");
+
+test('Seed data uses correct API (this.seed instead of table.EntityName.create)', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [{
+        __name: 'Settings',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        disable_rag: { name: 'disable_rag', type: 'integer' }
+    }];
+    const seedData = {
+        Settings: [{ disable_rag: 0 }]
+    };
+
+    const migrationCode = migrations.template('TestMigration', oldSchema, newSchema, seedData);
+
+    assert(migrationCode.includes("this.seed('Settings'"), 'Should use this.seed() method');
+    assert(!migrationCode.includes('table.Settings.create'), 'Should NOT use table.Settings.create()');
+});
+
+test('No duplicate createTable calls for tables with seed data', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [
+        {
+            __name: 'Document',
+            id: { name: 'id', type: 'integer', primaryKey: true }
+        },
+        {
+            __name: 'Settings',
+            id: { name: 'id', type: 'integer', primaryKey: true }
+        }
+    ];
+    const seedData = {
+        Settings: [{ id: 1 }]
+    };
+
+    const migrationCode = migrations.template('TestMigration', oldSchema, newSchema, seedData);
+
+    const settingsCreateMatches = migrationCode.match(/createTable\(table\.Settings\)/g);
+    const settingsCreateCount = settingsCreateMatches ? settingsCreateMatches.length : 0;
+
+    assert(settingsCreateCount === 1, `Expected 1 createTable for Settings, got ${settingsCreateCount}`);
+});
+
+test('No duplicate seed insertion calls', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [{
+        __name: 'Settings',
+        id: { name: 'id', type: 'integer', primaryKey: true }
+    }];
+    const seedData = {
+        Settings: [{ id: 1, value: 'test' }]
+    };
+
+    const migrationCode = migrations.template('TestMigration', oldSchema, newSchema, seedData);
+
+    const seedMatches = migrationCode.match(/this\.seed\('Settings'/g);
+    const seedCount = seedMatches ? seedMatches.length : 0;
+
+    assert(seedCount === 1, `Expected 1 seed call, got ${seedCount}`);
+});
+
+test('No duplicate dropTable calls in down migration', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [{
+        __name: 'Settings',
+        id: { name: 'id', type: 'integer', primaryKey: true }
+    }];
+    const seedData = {
+        Settings: [{ id: 1 }]
+    };
+
+    const migrationCode = migrations.template('TestMigration', oldSchema, newSchema, seedData);
+
+    const dropMatches = migrationCode.match(/dropTable\(table\.Settings\)/g);
+    const dropCount = dropMatches ? dropMatches.length : 0;
+
+    assert(dropCount === 1, `Expected 1 dropTable call, got ${dropCount}`);
+});
+
+test('Complex scenario: Multiple tables with seed data, indexes, and composite indexes', () => {
+    const migrations = new Migrations();
+    const oldSchema = [];
+    const newSchema = [
+        {
+            __name: 'Document',
+            id: { name: 'id', type: 'integer', primaryKey: true },
+            embedding_model_id: { name: 'embedding_model_id', type: 'integer', indexes: ['idx_doc_embed'] }
+        },
+        {
+            __name: 'DocumentChunk',
+            id: { name: 'id', type: 'integer', primaryKey: true },
+            __compositeIndexes: [{
+                name: 'idx_chunk_unique',
+                columns: ['doc_id', 'chunk_index'],
+                unique: true
+            }]
+        },
+        {
+            __name: 'Settings',
+            id: { name: 'id', type: 'integer', primaryKey: true },
+            disable_rag: { name: 'disable_rag', type: 'integer' }
+        },
+        {
+            __name: 'Job',
+            id: { name: 'id', type: 'integer', primaryKey: true }
+        }
+    ];
+    const seedData = {
+        Settings: [{ disable_rag: 0 }]
+    };
+
+    const migrationCode = migrations.template('InitialCreate', oldSchema, newSchema, seedData);
+
+    // Check each table appears exactly once
+    const docCreate = (migrationCode.match(/createTable\(table\.Document\)/g) || []).length;
+    const chunkCreate = (migrationCode.match(/createTable\(table\.DocumentChunk\)/g) || []).length;
+    const settingsCreate = (migrationCode.match(/createTable\(table\.Settings\)/g) || []).length;
+    const jobCreate = (migrationCode.match(/createTable\(table\.Job\)/g) || []).length;
+
+    assert(docCreate === 1, `Document: Expected 1 createTable, got ${docCreate}`);
+    assert(chunkCreate === 1, `DocumentChunk: Expected 1 createTable, got ${chunkCreate}`);
+    assert(settingsCreate === 1, `Settings: Expected 1 createTable, got ${settingsCreate}`);
+    assert(jobCreate === 1, `Job: Expected 1 createTable, got ${jobCreate}`);
+
+    // Check seed uses correct API
+    assert(migrationCode.includes("this.seed('Settings'"), 'Should use this.seed() for Settings');
+    assert(!migrationCode.includes('table.Settings.create'), 'Should NOT use table.Settings.create');
+
+    // Check indexes have await
+    assert(migrationCode.includes('await this.createIndex'), 'Indexes should have await');
+    assert(migrationCode.includes('await this.createCompositeIndex'), 'Composite indexes should have await');
+});
+
+// =============================================================================
+// Test Results Summary
+// =============================================================================
+console.log("\n" + "=".repeat(68));
+console.log(`\n📊 Test Results: ${passed} passed, ${failed} failed\n`);
+
+if (failed === 0) {
+    console.log("✅ All tests passed! v0.3.34 fixes are working correctly.\n");
+    process.exit(0);
+} else {
+    console.log(`⚠️  ${failed} test(s) failed. Please review the output above.\n`);
+    process.exit(1);
+}

package/test/debug-id-test.js

@@ -1,63 +0,0 @@
-/**
- * Debug test to trace ID setting
- */
-
-const masterrecord = require('../MasterRecord.js');
-const path = require('path');
-const fs = require('fs');
-
-class User {
-    id(db) {
-        db.integer().primary().auto();
-    }
-    name(db) {
-        db.string();
-    }
-}
-
-class TestContext extends masterrecord.context {
-    constructor() {
-        super();
-        this.database = path.join(__dirname, '..', 'database', 'debugIdTest.db');
-    }
-    onConfig(db) {
-        this.dbset(User);
-    }
-}
-
-// Clean
-if (fs.existsSync(path.join(__dirname, '..', 'database', 'debugIdTest.db'))) {
-    fs.unlinkSync(path.join(__dirname, '..', 'database', 'debugIdTest.db'));
-}
-
-async function test() {
-    const db = new TestContext();
-    db.onConfig();
-
-    const user = db.User.new();
-    user.name = 'Test';
-
-    console.log('\n=== Manual ID set test ===');
-    console.log('Before manual set - user.id:', user.id);
-
-    user.id = 123;
-    console.log('After user.id = 123 - user.id:', user.id);
-    console.log('After manual set - user.__proto__._id:', user.__proto__._id);
-
-    user.id = 456;
-    console.log('After user.id = 456 - user.id:', user.id);
-
-    console.log('\n=== Now test with save ===');
-    const user2 = db.User.new();
-    user2.name = 'Test2';
-
-    console.log('Before save - tracked entities:', db.__trackedEntities.length);
-    console.log('Before save - user2.__state:', user2.__state);
-
-    await user2.save();
-
-    console.log('After save - user2.id:', user2.id);
-    console.log('After save - user2.__proto__._id:', user2.__proto__._id);
-}
-
-test().catch(console.error);