masterrecord 0.3.49 → 0.3.50

package/.claude/settings.local.json

@@ -63,7 +63,8 @@
       "Bash(npx mocha:*)",
       "Bash(masterrecord add-migration:*)",
       "Bash(masterrecord:*)",
-      "Bash(git -C /Users/alexanderrich/Documents/development/bookbaghq/bookbag-training log --oneline --all -- *MASTERRECORD_ISSUE*)"
+      "Bash(git -C /Users/alexanderrich/Documents/development/bookbaghq/bookbag-training log --oneline --all -- *MASTERRECORD_ISSUE*)",
+      "Bash(npm ls -g masterrecord 2>&1 | head -5)"
     ],
     "deny": [],
     "ask": []

package/context.js

@@ -32,6 +32,19 @@ const MySQLAsyncClient = require('masterrecord/mySQLConnect');
 const PostgresClient = require('masterrecord/postgresSyncConnect');
 const QueryCache = require('./Cache/QueryCache');
 
+// ============================================================================
+// GLOBAL POOL REGISTRY - One pool per database, shared across all contexts
+// ============================================================================
+
+const _pools = global.__MR_POOLS__ || (global.__MR_POOLS__ = new Map());
+
+function _poolKey(type, cfg) {
+    if (type === 'sqlite') return `sqlite:${cfg.completeConnection || cfg.connection}`;
+    const host = cfg.host || 'localhost';
+    const port = cfg.port || (type === 'mysql' ? 3306 : 5432);
+    return `${type}:${cfg.user}@${host}:${port}/${cfg.database}`;
+}
+
 // ============================================================================
 // CONSTANTS - Extract all magic numbers for maintainability
 // ============================================================================
@@ -329,6 +342,16 @@ class context {
                 );
             }
 
+            const key = _poolKey('mysql', env);
+            if (_pools.has(key)) {
+                const cached = _pools.get(key);
+                cached.refCount++;
+                this._SQLEngine = cached.engine;
+                this.isMySQL = true;
+                console.log(`[MySQL] Reusing pool for ${env.database} (refs: ${cached.refCount})`);
+                return cached.client;
+            }
+
             console.log('[MySQL] Initializing async connection pool...');
             const client = new MySQLAsyncClient(env);
             await client.connect();
@@ -339,6 +362,7 @@ class context {
             this._SQLEngine.__name = sqlName;
             this.isMySQL = true;
 
+            _pools.set(key, { client, engine: this._SQLEngine, refCount: 1, dbType: 'mysql' });
             console.log('[MySQL] Connection pool ready');
             return client;
         } catch (error) {
@@ -401,12 +425,24 @@ class context {
                 );
             }
 
+            const key = _poolKey('postgres', env);
+            if (_pools.has(key)) {
+                const cached = _pools.get(key);
+                cached.refCount++;
+                this._SQLEngine = cached.engine;
+                this._SQLEngine.__name = sqlName;
+                console.log(`[PostgreSQL] Reusing pool for ${env.database} (refs: ${cached.refCount})`);
+                return cached.pool;
+            }
+
             const connection = new PostgresClient();
             await connection.connect(env);
             this._SQLEngine = connection.getEngine();
             this._SQLEngine.__name = sqlName;
 
-            return connection.getPool();
+            const pool = connection.getPool();
+            _pools.set(key, { pool, engine: this._SQLEngine, client: connection, refCount: 1, dbType: 'postgres' });
+            return pool;
         } catch (error) {
             // Preserve original error if it's already a ContextError
             if (error instanceof ContextError) {
@@ -700,8 +736,20 @@ class context {
                 }
 
                 const sqliteOptions = { ...options, completeConnection: dbPath };
+
+                const sqliteKey = _poolKey('sqlite', sqliteOptions);
+                if (_pools.has(sqliteKey)) {
+                    const cached = _pools.get(sqliteKey);
+                    cached.refCount++;
+                    this.db = cached.db;
+                    this._SQLEngine = cached.engine;
+                    return this;
+                }
+
                 this.db = this.__SQLiteInit(sqliteOptions, 'better-sqlite3');
                 this._SQLEngine.setDB(this.db, 'better-sqlite3');
+
+                _pools.set(sqliteKey, { db: this.db, engine: this._SQLEngine, refCount: 1, dbType: 'sqlite' });
                 return this;
             }
 
@@ -843,8 +891,19 @@ class context {
                 fs.mkdirSync(dbDirectory, { recursive: true });
             }
 
+            const sqliteKey = _poolKey('sqlite', options);
+            if (_pools.has(sqliteKey)) {
+                const cached = _pools.get(sqliteKey);
+                cached.refCount++;
+                this.db = cached.db;
+                this._SQLEngine = cached.engine;
+                return this;
+            }
+
             this.db = this.__SQLiteInit(options, 'better-sqlite3');
             this._SQLEngine.setDB(this.db, 'better-sqlite3');
+
+            _pools.set(sqliteKey, { db: this.db, engine: this._SQLEngine, refCount: 1, dbType: 'sqlite' });
             return this;
         } catch (error) {
             // Preserve original error if it's already a ContextError
@@ -1927,11 +1986,72 @@ class context {
      * db.close();  // Close connections
      */
     async close() {
+        // Find this instance's pool in the registry and decrement
+        for (const [key, entry] of _pools) {
+            if (entry.engine === this._SQLEngine) {
+                entry.refCount--;
+                if (entry.refCount <= 0) {
+                    _pools.delete(key);
+                    if (this._SQLEngine && typeof this._SQLEngine.close === 'function') {
+                        await this._SQLEngine.close();
+                    }
+                }
+                this._SQLEngine = null;
+                this.db = null;
+                return;
+            }
+        }
+
+        // Fallback (not in registry)
         if (this._SQLEngine && typeof this._SQLEngine.close === 'function') {
             return await this._SQLEngine.close();
         }
     }
 
+    /**
+     * Close all shared connection pools, regardless of reference count.
+     * Useful for graceful shutdown or test cleanup.
+     *
+     * @static
+     * @async
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Graceful shutdown
+     * process.on('SIGTERM', async () => {
+     *     await context.closeAll();
+     *     process.exit(0);
+     * });
+     */
+    static async closeAll() {
+        for (const [key, entry] of _pools) {
+            try {
+                if (entry.engine && typeof entry.engine.close === 'function') {
+                    await entry.engine.close();
+                }
+            } catch (err) {
+                console.error('[MasterRecord] Error closing pool:', err.message);
+            }
+        }
+        _pools.clear();
+    }
+
+    /**
+     * Get statistics about active connection pools.
+     *
+     * @static
+     * @returns {Array<{key: string, dbType: string, refCount: number}>}
+     *
+     * @example
+     * console.log(context.getPoolStats());
+     * // [{ key: 'mysql:root@localhost:3306/mydb', dbType: 'mysql', refCount: 3 }]
+     */
+    static getPoolStats() {
+        return Array.from(_pools.entries()).map(([key, entry]) => ({
+            key, dbType: entry.dbType, refCount: entry.refCount
+        }));
+    }
+
     /**
      * Attach a detached entity and mark it as modified
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.49",
+  "version": "0.3.50",
   "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/test/pool-registry-test.js

@@ -0,0 +1,303 @@
+/**
+ * Test: Global Pool Registry — One Pool Per Database
+ *
+ * Verifies that multiple context instances share the same connection pool
+ * instead of creating a new pool per instance (the bug this fixes).
+ */
+
+const context = require('../context');
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║         Pool Registry Test — One Pool Per Database            ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, passMsg, failMsg) {
+    if (condition) {
+        console.log(`   ✓ ${passMsg}`);
+        passed++;
+    } else {
+        console.log(`   ✗ ${failMsg}`);
+        failed++;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: _pools global registry exists
+// ---------------------------------------------------------------------------
+console.log("📝 Test 1: Global pool registry exists");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    const pools = global.__MR_POOLS__;
+    assert(
+        pools instanceof Map,
+        "global.__MR_POOLS__ is a Map",
+        `global.__MR_POOLS__ is not a Map (got: ${typeof pools})`
+    );
+} catch (err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// ---------------------------------------------------------------------------
+// Test 2: closeAll() is a static method
+// ---------------------------------------------------------------------------
+console.log("\n📝 Test 2: context.closeAll() is a static method");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    assert(
+        typeof context.closeAll === 'function',
+        "context.closeAll exists and is a function",
+        `context.closeAll is not a function (got: ${typeof context.closeAll})`
+    );
+} catch (err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// ---------------------------------------------------------------------------
+// Test 3: getPoolStats() is a static method
+// ---------------------------------------------------------------------------
+console.log("\n📝 Test 3: context.getPoolStats() is a static method");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    assert(
+        typeof context.getPoolStats === 'function',
+        "context.getPoolStats exists and is a function",
+        `context.getPoolStats is not a function (got: ${typeof context.getPoolStats})`
+    );
+} catch (err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// ---------------------------------------------------------------------------
+// Test 4: getPoolStats() returns an array
+// ---------------------------------------------------------------------------
+console.log("\n📝 Test 4: getPoolStats() returns an array");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    const stats = context.getPoolStats();
+    assert(
+        Array.isArray(stats),
+        `getPoolStats() returned array with ${stats.length} entries`,
+        `Expected array, got: ${typeof stats}`
+    );
+} catch (err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// Async tests wrapped in IIFE
+(async function runAsyncTests() {
+
+    // ---------------------------------------------------------------------------
+    // Test 5: closeAll() clears the registry
+    // ---------------------------------------------------------------------------
+    console.log("\n📝 Test 5: closeAll() clears the registry");
+    console.log("──────────────────────────────────────────────────");
+
+    try {
+        const pools = global.__MR_POOLS__;
+        pools.set('test:fake@localhost:5432/testdb', {
+            engine: { close: function() {} },
+            refCount: 1,
+            dbType: 'test'
+        });
+
+        const beforeSize = pools.size;
+        await context.closeAll();
+        const afterSize = pools.size;
+
+        assert(
+            beforeSize > 0 && afterSize === 0,
+            `Registry had ${beforeSize} entry, now has ${afterSize} after closeAll()`,
+            `Expected registry to be cleared (before: ${beforeSize}, after: ${afterSize})`
+        );
+    } catch (err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Test 6: close() on instance decrements refCount
+    // ---------------------------------------------------------------------------
+    console.log("\n📝 Test 6: close() decrements refCount");
+    console.log("──────────────────────────────────────────────────");
+
+    try {
+        const pools = global.__MR_POOLS__;
+        const fakeEngine = { close: function() { return Promise.resolve(); } };
+
+        pools.set('test:ref-count-test', {
+            engine: fakeEngine,
+            refCount: 2,
+            dbType: 'test'
+        });
+
+        class TestCtx extends context {
+            constructor() { super(); }
+        }
+
+        const db = new TestCtx();
+        db._SQLEngine = fakeEngine;
+
+        await db.close();
+
+        const entry = pools.get('test:ref-count-test');
+
+        assert(
+            entry && entry.refCount === 1,
+            "refCount decremented from 2 to 1 — pool NOT closed (still has references)",
+            entry ? `Expected refCount 1, got ${entry.refCount}` : "Entry was deleted (should still exist with refCount 1)"
+        );
+
+        pools.delete('test:ref-count-test');
+    } catch (err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Test 7: close() removes pool when refCount reaches 0
+    // ---------------------------------------------------------------------------
+    console.log("\n📝 Test 7: close() removes pool when refCount reaches 0");
+    console.log("──────────────────────────────────────────────────");
+
+    try {
+        const pools = global.__MR_POOLS__;
+        let closeCalled = false;
+        const fakeEngine = { close: function() { closeCalled = true; return Promise.resolve(); } };
+
+        pools.set('test:last-ref-test', {
+            engine: fakeEngine,
+            refCount: 1,
+            dbType: 'test'
+        });
+
+        class TestCtx2 extends context {
+            constructor() { super(); }
+        }
+
+        const db = new TestCtx2();
+        db._SQLEngine = fakeEngine;
+
+        await db.close();
+
+        const entry = pools.get('test:last-ref-test');
+
+        assert(
+            !entry && closeCalled,
+            "Pool removed from registry when refCount reached 0, engine.close() called",
+            entry ? `Entry still exists with refCount ${entry.refCount}` : "Entry removed but engine.close() was not called"
+        );
+    } catch (err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Test 8: getPoolStats() returns correct shape
+    // ---------------------------------------------------------------------------
+    console.log("\n📝 Test 8: Pool registry entries have correct shape");
+    console.log("──────────────────────────────────────────────────");
+
+    try {
+        const pools = global.__MR_POOLS__;
+        const fakeEngine = { close: function() {} };
+
+        pools.set('mysql:testuser@localhost:3306/testdb', {
+            client: {},
+            engine: fakeEngine,
+            refCount: 3,
+            dbType: 'mysql'
+        });
+
+        const stats = context.getPoolStats();
+        const mysqlStat = stats.find(function(s) { return s.key === 'mysql:testuser@localhost:3306/testdb'; });
+
+        assert(
+            mysqlStat && mysqlStat.dbType === 'mysql' && mysqlStat.refCount === 3,
+            `getPoolStats() correct: ${mysqlStat.key} (type: ${mysqlStat.dbType}, refs: ${mysqlStat.refCount})`,
+            `Expected mysql entry with refCount 3, got: ${JSON.stringify(mysqlStat)}`
+        );
+
+        pools.delete('mysql:testuser@localhost:3306/testdb');
+    } catch (err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Test 9: Two context instances with same fake engine share one pool entry
+    // ---------------------------------------------------------------------------
+    console.log("\n📝 Test 9: Two instances sharing a pool both decrement correctly");
+    console.log("──────────────────────────────────────────────────");
+
+    try {
+        const pools = global.__MR_POOLS__;
+        let closeCalled = false;
+        const sharedEngine = { close: function() { closeCalled = true; return Promise.resolve(); } };
+
+        pools.set('test:shared-engine', {
+            engine: sharedEngine,
+            refCount: 2,
+            dbType: 'test'
+        });
+
+        class TestCtx3 extends context {
+            constructor() { super(); }
+        }
+
+        const db1 = new TestCtx3();
+        db1._SQLEngine = sharedEngine;
+
+        const db2 = new TestCtx3();
+        db2._SQLEngine = sharedEngine;
+
+        // First close: refCount 2 -> 1
+        await db1.close();
+        let entry = pools.get('test:shared-engine');
+        const afterFirst = entry ? entry.refCount : -1;
+
+        // Second close: refCount 1 -> 0, pool removed
+        await db2.close();
+        entry = pools.get('test:shared-engine');
+
+        assert(
+            afterFirst === 1 && !entry && closeCalled,
+            "First close: refs 2->1. Second close: refs 1->0, pool destroyed, engine.close() called",
+            `afterFirst=${afterFirst}, entryGone=${!entry}, closeCalled=${closeCalled}`
+        );
+    } catch (err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Summary
+    // ---------------------------------------------------------------------------
+    console.log("\n╔════════════════════════════════════════════════════════════════╗");
+    console.log("║                        Test Summary                          ║");
+    console.log("╚════════════════════════════════════════════════════════════════╝");
+    console.log(`\n   ✓ Passed: ${passed}`);
+    console.log(`   ✗ Failed: ${failed}`);
+    console.log(`   📊 Total:  ${passed + failed}\n`);
+
+    if (failed === 0) {
+        console.log("   🎉 All tests passed!\n");
+        console.log("   ✅ Global pool registry is working correctly");
+        console.log("   ✅ One pool per database — no more connection exhaustion\n");
+        process.exit(0);
+    } else {
+        console.log("   ❌ Some tests failed\n");
+        process.exit(1);
+    }
+
+})();

package/test/multiContextCacheSimple.test.js

@@ -1,185 +0,0 @@
-/**
- * Test: Static Cache Sharing
- * Verifies the cache is static/shared as designed
- */
-
-const QueryCache = require('../Cache/QueryCache');
-
-console.log("╔════════════════════════════════════════════════════════════════╗");
-console.log("║              Static Cache Test                                 ║");
-console.log("╚════════════════════════════════════════════════════════════════╝\n");
-
-let passed = 0;
-let failed = 0;
-
-// Simulate context class with static shared cache
-class SimulatedContext {
-    static _sharedQueryCache = null;
-
-    constructor() {
-        // Initialize shared query cache (only once across all instances)
-        if (!SimulatedContext._sharedQueryCache) {
-            SimulatedContext._sharedQueryCache = new QueryCache({
-                ttl: 5 * 60 * 1000,
-                maxSize: 1000,
-                enabled: true
-            });
-        }
-
-        // Reference the shared cache
-        this._queryCache = SimulatedContext._sharedQueryCache;
-    }
-
-    getCacheStats() {
-        return this._queryCache.getStats();
-    }
-
-    clearQueryCache() {
-        this._queryCache.clear();
-    }
-}
-
-// Test 1: Multiple instances share the same cache
-console.log("📝 Test 1: Multiple instances share same cache");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const ctx1 = new SimulatedContext();
-    const ctx2 = new SimulatedContext();
-
-    const areSame = ctx1._queryCache === ctx2._queryCache;
-    const isStatic = ctx1._queryCache === SimulatedContext._sharedQueryCache;
-
-    if(areSame && isStatic) {
-        console.log("   ✓ Both instances share the same cache");
-        console.log("   ✓ Cache is stored in static property");
-        passed++;
-    } else {
-        console.log(`   ✗ Instances have separate caches`);
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 2: Cache SET in one instance visible in another
-console.log("\n📝 Test 2: Cache operations are shared");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const ctx1 = new SimulatedContext();
-    const ctx2 = new SimulatedContext();
-
-    // Instance 1: Add to cache
-    const key = ctx1._queryCache.generateKey('SELECT * FROM users', [], 'users');
-    ctx1._queryCache.set(key, [{ id: 1, name: 'Alice' }], 'users');
-
-    // Instance 2: Should see the same cached data
-    const cached = ctx2._queryCache.get(key);
-
-    if(cached && cached[0].name === 'Alice') {
-        console.log("   ✓ Cache data visible across instances");
-        console.log("   ✓ Data written by ctx1, read by ctx2");
-        passed++;
-    } else {
-        console.log(`   ✗ Cache data not shared`);
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 3: Cache invalidation in one instance affects another
-console.log("\n📝 Test 3: Cache invalidation is shared");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const ctx1 = new SimulatedContext();
-    const ctx2 = new SimulatedContext();
-
-    // Clear for clean test
-    ctx1._queryCache.clear();
-
-    // Instance 1: Add entries
-    const key1 = ctx1._queryCache.generateKey('query1', [], 'users');
-    const key2 = ctx1._queryCache.generateKey('query2', [], 'users');
-    ctx1._queryCache.set(key1, { id: 1 }, 'users');
-    ctx1._queryCache.set(key2, { id: 2 }, 'users');
-
-    // Verify both cached
-    const before1 = ctx1._queryCache.get(key1);
-    const before2 = ctx2._queryCache.get(key2);
-
-    // Instance 2: Invalidate
-    ctx2._queryCache.invalidateTable('users');
-
-    // Both instances should see empty cache
-    const after1 = ctx1._queryCache.get(key1);
-    const after2 = ctx2._queryCache.get(key2);
-
-    if(before1 !== null && before2 !== null && after1 === null && after2 === null) {
-        console.log("   ✓ Invalidation in ctx2 affected ctx1");
-        console.log("   ✓ Cache properly shared");
-        passed++;
-    } else {
-        console.log(`   ✗ Invalidation not shared`);
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 4: Statistics are shared
-console.log("\n📝 Test 4: Statistics are shared");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const ctx1 = new SimulatedContext();
-    const ctx2 = new SimulatedContext();
-
-    // Clear for clean test
-    ctx1.clearQueryCache();
-
-    // Instance 1: Generate activity
-    const key = ctx1._queryCache.generateKey('test', [], 'users');
-    ctx1._queryCache.set(key, 'data', 'users');
-    ctx1._queryCache.get(key);  // Hit
-    ctx1._queryCache.get('nonexistent');  // Miss
-
-    // Both instances should see same stats
-    const stats1 = ctx1.getCacheStats();
-    const stats2 = ctx2.getCacheStats();
-
-    if(stats1.hits === 1 && stats2.hits === 1 && stats1.misses === 1 && stats2.misses === 1) {
-        console.log("   ✓ Statistics shared across instances");
-        console.log(`   ✓ Both see: ${stats1.hits} hit, ${stats1.misses} miss`);
-        passed++;
-    } else {
-        console.log(`   ✗ Statistics not shared`);
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Summary
-console.log("\n╔════════════════════════════════════════════════════════════════╗");
-console.log("║                        Test Summary                            ║");
-console.log("╚════════════════════════════════════════════════════════════════╝");
-console.log(`\n   ✓ Passed: ${passed}`);
-console.log(`   ✗ Failed: ${failed}`);
-console.log(`   📊 Total:  ${passed + failed}\n`);
-
-if(failed === 0) {
-    console.log("   🎉 All tests passed!\n");
-    console.log("   ✅ Static cache pattern verified");
-    console.log("   ✅ BUG FIX CONFIRMED: Multi-context cache sharing works!\n");
-    process.exit(0);
-} else {
-    console.log("   ❌ Some tests failed\n");
-    process.exit(1);
-}

package/test/simple-id-test.js

@@ -1,61 +0,0 @@
-/**
- * Simple test to check if ID is set after save
- */
-
-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', 'simpleIdTest.db');
-    }
-    onConfig(db) {
-        this.dbset(User);
-    }
-}
-
-// Clean
-if (fs.existsSync(path.join(__dirname, '..', 'database', 'simpleIdTest.db'))) {
-    fs.unlinkSync(path.join(__dirname, '..', 'database', 'simpleIdTest.db'));
-}
-
-async function test() {
-    const db = new TestContext();
-    db.onConfig();
-
-    const user = db.User.new();
-    user.name = 'Test';
-
-    console.log('Before save - user.id:', user.id);
-    console.log('Before save - user.__proto__:', Object.keys(user.__proto__));
-
-    await user.save();
-
-    console.log('After save - user.id:', user.id);
-    console.log('After save - user.__proto__:', Object.keys(user.__proto__));
-    console.log('After save - user.__proto__._id:', user.__proto__._id);
-
-    // Try direct access
-    console.log('Direct access test:');
-    for (const key in user) {
-        if (key === 'id') {
-            console.log('Found id property via for-in');
-        }
-    }
-
-    console.log('Has own property id?', user.hasOwnProperty('id'));
-    console.log('Keys:', Object.keys(user));
-}
-
-test().catch(console.error);

package/test/single-user-id-test.js

@@ -1,70 +0,0 @@
-/**
- * Single user ID test
- */
-
-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();
-    }
-    onConfig(db) {
-        this.dbset(User);
-    }
-}
-
-// Clean
-const dbPath = path.join(__dirname, '..', 'database', 'singleUserTest.db');
-if (fs.existsSync(dbPath)) {
-    fs.unlinkSync(dbPath);
-}
-
-async function test() {
-    const db = new TestContext();
-
-    // Manually initialize SQLite for testing
-    const SQLLiteEngine = require('../SQLLiteEngine');
-    const sqlite3 = require('better-sqlite3');
-
-    db.isSQLite = true;
-    db.isMySQL = false;
-    db.isPostgres = false;
-    db._SQLEngine = new SQLLiteEngine();
-    db.db = new sqlite3(dbPath);
-    db._SQLEngine.setDB(db.db, 'better-sqlite3');
-
-    db.onConfig();
-
-    // Create table
-    db.db.exec('CREATE TABLE IF NOT EXISTS User (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)');
-
-    const user = db.User.new();
-    user.name = 'Test';
-
-    console.log('Before save - user.id:', user.id);
-    console.log('Before save - tracked:', db.__trackedEntities.length);
-
-    await user.save();
-
-    console.log('After save - user.id:', user.id);
-    console.log('After save - user.__proto__._id:', user.__proto__._id);
-
-    if (user.id) {
-        console.log('✓ SUCCESS - ID was set to:', user.id);
-    } else {
-        console.log('✗ FAIL - ID is still undefined');
-    }
-}
-
-test().catch(console.error);

package/test/verifyFindById.js

@@ -1,169 +0,0 @@
-/**
- * Verify .findById() Method Implementation
- *
- * Simple verification that the .findById() method exists
- */
-
-const fs = require('fs');
-const path = require('path');
-
-console.log("╔════════════════════════════════════════════════════════════════╗");
-console.log("║         Verify .findById() Method Implementation              ║");
-console.log("╚════════════════════════════════════════════════════════════════╝\n");
-
-let passed = 0;
-let failed = 0;
-
-// Test 1: Check file exists
-console.log("📝 Test 1: Check queryMethods.js exists");
-console.log("──────────────────────────────────────────────────");
-
-const queryMethodsPath = path.join(__dirname, '../QueryLanguage/queryMethods.js');
-
-try {
-    if(fs.existsSync(queryMethodsPath)) {
-        console.log("   ✓ queryMethods.js found");
-        passed++;
-    } else {
-        console.log("   ✗ queryMethods.js not found");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 2: Check .findById() method exists
-console.log("\n📝 Test 2: Check .findById() method is implemented");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const content = fs.readFileSync(queryMethodsPath, 'utf8');
-
-    const hasFindByIdMethod = /findById\s*\(\s*id\s*\)\s*\{/.test(content);
-    const hasComment = /Convenience method.*Find record by primary key/i.test(content);
-    const hasPrimaryKeyDetection = /Find the primary key field/i.test(content);
-
-    if(hasFindByIdMethod) {
-        console.log("   ✓ findById() method definition found");
-
-        if(hasComment) {
-            console.log("   ✓ Method documentation present");
-        }
-
-        if(hasPrimaryKeyDetection) {
-            console.log("   ✓ Primary key detection code present");
-        }
-
-        passed++;
-    } else {
-        console.log("   ✗ findById() method not found");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 3: Verify method implementation
-console.log("\n📝 Test 3: Verify method implementation details");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const content = fs.readFileSync(queryMethodsPath, 'utf8');
-
-    const checks = [
-        { name: 'Primary key loop', pattern: /for\s*\(\s*const\s+fieldName\s+in\s+this\.__entity\s*\)/ },
-        { name: 'Primary key check', pattern: /field\.primary\s*===\s*true/ },
-        { name: 'Error for missing PK', pattern: /No primary key defined/ },
-        { name: 'WHERE clause builder', pattern: /whereClause\s*=/ },
-        { name: 'Calls .where()', pattern: /this\.where\(whereClause/ },
-        { name: 'Calls .single()', pattern: /\.single\(\)/ }
-    ];
-
-    let allChecksPass = true;
-
-    checks.forEach(check => {
-        if(check.pattern.test(content)) {
-            console.log(`   ✓ ${check.name}`);
-        } else {
-            console.log(`   ✗ Missing: ${check.name}`);
-            allChecksPass = false;
-        }
-    });
-
-    if(allChecksPass) {
-        passed++;
-    } else {
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 4: Check method placement
-console.log("\n📝 Test 4: Verify method placement in file");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const content = fs.readFileSync(queryMethodsPath, 'utf8');
-
-    const findByIdIndex = content.indexOf('findById(id)');
-    const singleIndex = content.indexOf('single(){');
-
-    if(findByIdIndex > 0 && singleIndex > 0 && findByIdIndex < singleIndex) {
-        console.log("   ✓ findById() placed before single()");
-        console.log("   ✓ Correct location in class structure");
-        passed++;
-    } else if(findByIdIndex > 0) {
-        console.log("   ⚠  findById() exists but not in expected location");
-        console.log(`   ℹ  findById at position ${findByIdIndex}`);
-        passed++;
-    } else {
-        console.log("   ✗ Could not verify method placement");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Summary
-console.log("\n\n╔════════════════════════════════════════════════════════════════╗");
-console.log("║                       Verification Summary                     ║");
-console.log("╚════════════════════════════════════════════════════════════════╝");
-
-const total = passed + failed;
-const successRate = total > 0 ? Math.round((passed/total)*100) : 0;
-
-console.log(`\n   Total Checks: ${total}`);
-console.log(`   ✅ Passed: ${passed}`);
-console.log(`   ❌ Failed: ${failed}`);
-console.log(`   Success Rate: ${successRate}%\n`);
-
-if(failed === 0){
-    console.log("🎉 All verification checks passed!");
-    console.log("\n✨ .findById() Method Successfully Implemented!");
-    console.log("\n📖 Implementation Details:");
-    console.log("   File: QueryLanguage/queryMethods.js");
-    console.log("   Method: findById(id)");
-    console.log("   Purpose: Convenience method for finding by primary key");
-    console.log("\n📖 Features:");
-    console.log("   ✓ Automatically detects primary key field");
-    console.log("   ✓ Works with any primary key name (id, user_id, etc.)");
-    console.log("   ✓ Validates entity has a primary key");
-    console.log("   ✓ Returns single record or null");
-    console.log("   ✓ Generates proper parameterized query");
-    console.log("\n📖 Usage Examples:");
-    console.log("   const user = context.User.findById(123);");
-    console.log("   const lead = qaContext.QaLead.findById(leadId);");
-    console.log("   const post = context.Post.findById(postId);");
-    console.log("\n📖 Equivalent To:");
-    console.log("   const user = context.User.where(u => u.id == $$, 123).single();");
-    console.log("\n✅ Now compatible with Mongoose/Sequelize-style syntax!\n");
-    process.exit(0);
-} else {
-    console.log("⚠️  Some verification checks failed.");
-    process.exit(1);
-}

package/test/verifyNewMethod.js

@@ -1,191 +0,0 @@
-/**
- * Verify .new() Method Implementation
- *
- * Simple verification that the .new() method exists in queryMethods.js
- */
-
-const fs = require('fs');
-const path = require('path');
-
-console.log("╔════════════════════════════════════════════════════════════════╗");
-console.log("║         Verify .new() Method Implementation                   ║");
-console.log("╚════════════════════════════════════════════════════════════════╝\n");
-
-let passed = 0;
-let failed = 0;
-
-// Test 1: Check file exists
-console.log("📝 Test 1: Check queryMethods.js exists");
-console.log("──────────────────────────────────────────────────");
-
-const queryMethodsPath = path.join(__dirname, '../QueryLanguage/queryMethods.js');
-
-try {
-    if(fs.existsSync(queryMethodsPath)) {
-        console.log("   ✓ queryMethods.js found");
-        passed++;
-    } else {
-        console.log("   ✗ queryMethods.js not found");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 2: Check .new() method exists in file
-console.log("\n📝 Test 2: Check .new() method is implemented");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const content = fs.readFileSync(queryMethodsPath, 'utf8');
-
-    // Check for method definition
-    const hasNewMethod = /new\s*\(\s*\)\s*\{/.test(content);
-    const hasComment = /Creates a new empty entity instance/i.test(content);
-    const hasTracking = /this\.__context\.__track\(newEntity\)/.test(content);
-    const hasPropertySetup = /Object\.defineProperty\(newEntity/.test(content);
-
-    if(hasNewMethod) {
-        console.log("   ✓ new() method definition found");
-
-        if(hasComment) {
-            console.log("   ✓ Method documentation present");
-        }
-
-        if(hasTracking) {
-            console.log("   ✓ Entity tracking code present");
-        }
-
-        if(hasPropertySetup) {
-            console.log("   ✓ Property definition code present");
-        }
-
-        passed++;
-    } else {
-        console.log("   ✗ new() method not found in queryMethods.js");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 3: Verify method structure
-console.log("\n📝 Test 3: Verify method implementation structure");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const content = fs.readFileSync(queryMethodsPath, 'utf8');
-
-    // Extract the new() method
-    const methodMatch = content.match(/new\s*\(\s*\)\s*\{[\s\S]*?^\s{4}\}/m);
-
-    if(methodMatch) {
-        const methodCode = methodMatch[0];
-
-        const checks = [
-            { name: '__state = "insert"', pattern: /__state\s*:\s*"insert"/ },
-            { name: '__entity reference', pattern: /__entity\s*:\s*this\.__entity/ },
-            { name: '__context reference', pattern: /__context\s*:\s*this\.__context/ },
-            { name: '__dirtyFields array', pattern: /__dirtyFields\s*:\s*\[/ },
-            { name: 'Property loop', pattern: /for\s*\(\s*var\s+fieldName\s+in\s+this\.__entity\s*\)/ },
-            { name: 'Skip navigational', pattern: /isNavigational/ },
-            { name: 'defineProperty', pattern: /Object\.defineProperty/ },
-            { name: 'Track entity', pattern: /this\.__context\.__track/ },
-            { name: 'Return entity', pattern: /return\s+newEntity/ }
-        ];
-
-        let allChecksPass = true;
-
-        checks.forEach(check => {
-            if(check.pattern.test(methodCode)) {
-                console.log(`   ✓ ${check.name}`);
-            } else {
-                console.log(`   ✗ Missing: ${check.name}`);
-                allChecksPass = false;
-            }
-        });
-
-        if(allChecksPass) {
-            passed++;
-        } else {
-            failed++;
-        }
-    } else {
-        console.log("   ✗ Could not extract new() method code");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Test 4: Check method placement
-console.log("\n📝 Test 4: Verify method placement in file");
-console.log("──────────────────────────────────────────────────");
-
-try {
-    const content = fs.readFileSync(queryMethodsPath, 'utf8');
-
-    // Check that new() comes before add()
-    const newIndex = content.indexOf('new()');
-    const addIndex = content.indexOf('add(entityValue)');
-
-    if(newIndex > 0 && addIndex > 0 && newIndex < addIndex) {
-        console.log("   ✓ new() method placed before add()");
-        console.log("   ✓ Correct location in class structure");
-        passed++;
-    } else if(newIndex > 0 && addIndex > 0) {
-        console.log("   ⚠  new() method exists but not in expected location");
-        console.log(`   ℹ  new() at position ${newIndex}, add() at ${addIndex}`);
-        passed++;
-    } else {
-        console.log("   ✗ Could not verify method placement");
-        failed++;
-    }
-} catch(err) {
-    console.log(`   ✗ Error: ${err.message}`);
-    failed++;
-}
-
-// Summary
-console.log("\n\n╔════════════════════════════════════════════════════════════════╗");
-console.log("║                       Verification Summary                     ║");
-console.log("╚════════════════════════════════════════════════════════════════╝");
-
-const total = passed + failed;
-const successRate = total > 0 ? Math.round((passed/total)*100) : 0;
-
-console.log(`\n   Total Checks: ${total}`);
-console.log(`   ✅ Passed: ${passed}`);
-console.log(`   ❌ Failed: ${failed}`);
-console.log(`   Success Rate: ${successRate}%\n`);
-
-if(failed === 0){
-    console.log("🎉 All verification checks passed!");
-    console.log("\n✨ .new() Method Successfully Implemented!");
-    console.log("\n📖 Implementation Details:");
-    console.log("   File: QueryLanguage/queryMethods.js");
-    console.log("   Method: new()");
-    console.log("   Purpose: Create empty entity instances for INSERT operations");
-    console.log("\n📖 Features:");
-    console.log("   ✓ Creates entity with __state = 'insert'");
-    console.log("   ✓ Sets up property getters/setters for all fields");
-    console.log("   ✓ Tracks dirty fields automatically");
-    console.log("   ✓ Skips navigational properties (relationships)");
-    console.log("   ✓ Automatically tracks entity in context");
-    console.log("\n📖 Usage Example:");
-    console.log("   const job = context.QaIntelligenceJob.new();");
-    console.log("   job.annotation_id = 123;");
-    console.log("   job.job_type = 'auto_rewrite';");
-    console.log("   job.status = 'queued';");
-    console.log("   job.created_at = Date.now().toString();");
-    console.log("   context.saveChanges(); // INSERT INTO QaIntelligenceJob...");
-    console.log("\n✅ Bug Fixed: context.QaIntelligenceJob.new() now works!\n");
-    process.exit(0);
-} else {
-    console.log("⚠️  Some verification checks failed.");
-    console.log("   Review the implementation in queryMethods.js");
-    process.exit(1);
-}