masterrecord 0.3.48 → 0.3.50

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/v0.3.34-bug-fixes-test.js

@@ -116,7 +116,7 @@ test('Query builders correctly skip indexes property', () => {
 // =============================================================================
 console.log("\n📋 Test Suite 2: Index Creation with Await Keywords\n");
 
-test('createIndex generates code with await keyword', () => {
+test('New tables do NOT generate separate createIndex calls (createTable handles them)', () => {
     const migrations = new Migrations();
     const oldSchema = [];
     const newSchema = [{
@@ -127,12 +127,12 @@ test('createIndex generates code with await keyword', () => {
 
     const migrationCode = migrations.template('TestMigration', oldSchema, newSchema);
 
+    // For new tables, createTable() in schema.js handles indexes - no separate calls needed
     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');
+    assert(!createIndexMatches, 'New tables should NOT have separate createIndex calls');
 });
 
-test('createCompositeIndex generates code with await keyword', () => {
+test('New tables do NOT generate separate createCompositeIndex calls (createTable handles them)', () => {
     const migrations = new Migrations();
     const oldSchema = [];
     const newSchema = [{
@@ -147,8 +147,50 @@ test('createCompositeIndex generates code with await keyword', () => {
 
     const migrationCode = migrations.template('TestMigration', oldSchema, newSchema);
 
+    // For new tables, createTable() in schema.js handles composite indexes
     const compositeMatches = migrationCode.match(/await this\.createCompositeIndex/g);
-    assert(compositeMatches && compositeMatches.length > 0, 'createCompositeIndex should have await keyword');
+    assert(!compositeMatches, 'New tables should NOT have separate createCompositeIndex calls');
+});
+
+test('Adding index to EXISTING table generates createIndex with await', () => {
+    const migrations = new Migrations();
+    const oldSchema = [{
+        __name: 'User',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        email: { name: 'email', type: 'text' }
+    }];
+    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, 'Existing table with new index should have createIndex with await');
+});
+
+test('Adding composite index to EXISTING table generates createCompositeIndex with await', () => {
+    const migrations = new Migrations();
+    const oldSchema = [{
+        __name: 'User',
+        id: { name: 'id', type: 'integer', primaryKey: true }
+    }];
+    const newSchema = [{
+        __name: 'User',
+        id: { name: 'id', type: 'integer', primaryKey: true },
+        __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, 'Existing table with new composite index should have createCompositeIndex with await');
 });
 
 // =============================================================================
@@ -286,9 +328,9 @@ test('Complex scenario: Multiple tables with seed data, indexes, and composite i
     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');
+    // For new tables, createTable() handles indexes — no separate calls in template
+    assert(!migrationCode.includes('await this.createIndex'), 'New tables should not have separate createIndex calls');
+    assert(!migrationCode.includes('await this.createCompositeIndex'), 'New tables should not have separate createCompositeIndex calls');
 });
 
 // =============================================================================

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);