masterrecord 0.3.6 → 0.3.7

package/context.js

@@ -33,18 +33,26 @@ class context {
     isMySQL = false;
     isPostgres = false;
 
+    // Static shared cache - all context instances share the same cache
+    static _sharedQueryCache = null;
+
     constructor(){
         this. __environment = process.env.master;
         this.__name = this.constructor.name;
         this._SQLEngine = "";
         this.__trackedEntitiesMap = new Map();  // Initialize Map for O(1) lookups
 
-        // Initialize query cache
-        this._queryCache = new QueryCache({
-            ttl: process.env.QUERY_CACHE_TTL || 5 * 60 * 1000,  // 5 min default
-            maxSize: process.env.QUERY_CACHE_SIZE || 1000,
-            enabled: process.env.QUERY_CACHE_ENABLED !== 'false'
-        });
+        // Initialize shared query cache (only once across all instances)
+        if (!context._sharedQueryCache) {
+            context._sharedQueryCache = new QueryCache({
+                ttl: process.env.QUERY_CACHE_TTL || 5 * 60 * 1000,  // 5 min default
+                maxSize: process.env.QUERY_CACHE_SIZE || 1000,
+                enabled: process.env.QUERY_CACHE_ENABLED !== 'false'
+            });
+        }
+
+        // Reference the shared cache
+        this._queryCache = context._sharedQueryCache;
     }
 
         /* 

package/package.json

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

@@ -787,7 +787,7 @@ MasterRecord includes a **production-grade two-level caching system** similar to
 
 #### Basic Usage (Default Behavior)
 
-Caching is **enabled by default** and requires zero configuration:
+Caching is **enabled by default** and requires zero configuration. The cache is **shared across all context instances** to ensure consistency:
 
 ```javascript
 const db = new AppContext();
@@ -804,6 +804,10 @@ db.saveChanges();  // Cache for User table cleared
 
 // Next query hits database again (cache miss)
 const user3 = db.User.where(u => u.id == $$, 1).single();
+
+// Cache is shared across all context instances
+const db2 = new AppContext();
+const user4 = db2.User.findById(1);  // Also uses shared cache
 ```
 
 #### Configuration
@@ -988,6 +992,35 @@ if (parseFloat(stats.hitRate) < 50) {
 }
 ```
 
+#### Important: Shared Cache Behavior
+
+**The cache is shared across all context instances of the same class.** This ensures consistency:
+
+```javascript
+const db1 = new AppContext();
+const db2 = new AppContext();
+
+// Context 1: Cache data
+const user1 = db1.User.findById(1);  // DB query, cached
+
+// Context 2: Sees cached data
+const user2 = db2.User.findById(1);  // Cache hit!
+
+// Context 2: Updates invalidate cache for BOTH contexts
+user2.name = "Updated";
+db2.saveChanges();  // Invalidates shared cache
+
+// Context 1: Sees fresh data
+const user3 = db1.User.findById(1);  // Cache miss, fresh data
+console.log(user3.name);  // "Updated"
+```
+
+**Why shared cache?**
+- ✅ Prevents stale data across multiple context instances
+- ✅ Ensures all parts of your application see consistent data
+- ✅ Reduces memory usage (one cache instead of many)
+- ✅ Correct behavior for single-database applications (most use cases)
+
 ### Multi-Context Applications
 
 Manage multiple databases in one application:

package/test/multiContextCache.test.js

@@ -0,0 +1,230 @@
+/**
+ * Test: Multi-Context Cache Sharing
+ *
+ * Verifies that cache is shared across context instances
+ * so invalidation in one context affects all contexts
+ */
+
+const context = require('../context');
+const QueryCache = require('../Cache/QueryCache');
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║         Multi-Context Cache Sharing Test                      ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+let passed = 0;
+let failed = 0;
+
+// Test 1: Multiple context instances share the same cache
+console.log("📝 Test 1: Multiple contexts share same cache instance");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    class TestContext extends context {
+        constructor() {
+            super();
+        }
+    }
+
+    const db1 = new TestContext();
+    const db2 = new TestContext();
+
+    const areSameInstance = db1._queryCache === db2._queryCache;
+    const isSharedCache = db1._queryCache === context._sharedQueryCache;
+
+    if(areSameInstance && isSharedCache) {
+        console.log("   ✓ Both context instances share the same cache");
+        console.log("   ✓ Cache is stored in static property");
+        passed++;
+    } else {
+        console.log(`   ✗ Contexts have separate caches (BUG!)`);
+        console.log(`   ✗ db1._queryCache === db2._queryCache: ${areSameInstance}`);
+        console.log(`   ✗ Shared cache exists: ${isSharedCache}`);
+        failed++;
+    }
+} catch(err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// Test 2: Cache operations in one context affect another context
+console.log("\n📝 Test 2: Cache operations are shared");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    class TestContext extends context {
+        constructor() {
+            super();
+        }
+    }
+
+    const db1 = new TestContext();
+    const db2 = new TestContext();
+
+    // Context 1: Add to cache
+    const key = db1._queryCache.generateKey('SELECT * FROM users', [], 'users');
+    db1._queryCache.set(key, [{ id: 1, name: 'John' }], 'users');
+
+    // Context 2: Should see the same cached data
+    const cached = db2._queryCache.get(key);
+
+    if(cached && cached[0].name === 'John') {
+        console.log("   ✓ Cache data visible across contexts");
+        passed++;
+    } else {
+        console.log(`   ✗ Cache data not shared across contexts`);
+        failed++;
+    }
+} catch(err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// Test 3: Cache invalidation in one context affects another
+console.log("\n📝 Test 3: Cache invalidation is shared");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    class TestContext extends context {
+        constructor() {
+            super();
+        }
+    }
+
+    const db1 = new TestContext();
+    const db2 = new TestContext();
+
+    // Context 1: Add multiple entries to cache
+    const key1 = db1._queryCache.generateKey('SELECT * FROM users WHERE id=1', [], 'users');
+    const key2 = db1._queryCache.generateKey('SELECT * FROM users WHERE id=2', [], 'users');
+    db1._queryCache.set(key1, { id: 1, name: 'John' }, 'users');
+    db1._queryCache.set(key2, { id: 2, name: 'Jane' }, 'users');
+
+    // Verify both are cached
+    const beforeCached1 = db1._queryCache.get(key1);
+    const beforeCached2 = db1._queryCache.get(key2);
+
+    // Context 2: Invalidate User table
+    db2._queryCache.invalidateTable('users');
+
+    // Context 1: Should see invalidation
+    const afterCached1 = db1._queryCache.get(key1);
+    const afterCached2 = db1._queryCache.get(key2);
+
+    if(beforeCached1 !== null && beforeCached2 !== null && afterCached1 === null && afterCached2 === null) {
+        console.log("   ✓ Data was cached in context 1");
+        console.log("   ✓ Invalidation in context 2 affected context 1");
+        console.log("   ✓ Cache properly shared across contexts");
+        passed++;
+    } else {
+        console.log(`   ✗ Invalidation not shared properly`);
+        console.log(`   ✗ Before: cached1=${beforeCached1 !== null}, cached2=${beforeCached2 !== null}`);
+        console.log(`   ✗ After:  cached1=${afterCached1 !== null}, cached2=${afterCached2 !== null}`);
+        failed++;
+    }
+} catch(err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// Test 4: Cache statistics are shared
+console.log("\n📝 Test 4: Cache statistics are shared");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    // Clear existing cache for clean test
+    context._sharedQueryCache.clear();
+
+    class TestContext extends context {
+        constructor() {
+            super();
+        }
+    }
+
+    const db1 = new TestContext();
+    const db2 = new TestContext();
+
+    // Context 1: Generate hits/misses
+    const key = db1._queryCache.generateKey('query', [], 'users');
+    db1._queryCache.set(key, 'data', 'users');
+    db1._queryCache.get(key);  // Hit
+    db1._queryCache.get('nonexistent');  // Miss
+
+    // Context 2: Should see same stats
+    const stats1 = db1.getCacheStats();
+    const stats2 = db2.getCacheStats();
+
+    if(stats1.hits === 1 && stats2.hits === 1 && stats1.misses === 1 && stats2.misses === 1) {
+        console.log("   ✓ Cache statistics shared across contexts");
+        console.log(`   ✓ Both contexts see: ${stats1.hits} hit, ${stats1.misses} miss`);
+        passed++;
+    } else {
+        console.log(`   ✗ Statistics not shared`);
+        console.log(`   ✗ db1 stats: ${JSON.stringify(stats1)}`);
+        console.log(`   ✗ db2 stats: ${JSON.stringify(stats2)}`);
+        failed++;
+    }
+} catch(err) {
+    console.log(`   ✗ Error: ${err.message}`);
+    failed++;
+}
+
+// Test 5: Clear cache from one context affects all
+console.log("\n📝 Test 5: Clear cache affects all contexts");
+console.log("──────────────────────────────────────────────────");
+
+try {
+    class TestContext extends context {
+        constructor() {
+            super();
+        }
+    }
+
+    const db1 = new TestContext();
+    const db2 = new TestContext();
+
+    // Context 1: Add data
+    const key = db1._queryCache.generateKey('query', [], 'users');
+    db1._queryCache.set(key, 'data', 'users');
+
+    // Verify cached in both
+    const before1 = db1._queryCache.get(key);
+    const before2 = db2._queryCache.get(key);
+
+    // Context 2: Clear cache
+    db2.clearQueryCache();
+
+    // Both contexts should see empty cache
+    const after1 = db1._queryCache.get(key);
+    const after2 = db2._queryCache.get(key);
+
+    if(before1 !== null && before2 !== null && after1 === null && after2 === null) {
+        console.log("   ✓ Data cached in both contexts initially");
+        console.log("   ✓ Clear from context 2 affected context 1");
+        passed++;
+    } else {
+        console.log(`   ✗ Clear not shared across contexts`);
+        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("   ✅ Cache is properly shared across context instances");
+    console.log("   ✅ Bug fix verified: Multi-context cache invalidation works\n");
+    process.exit(0);
+} else {
+    console.log("   ❌ Some tests failed\n");
+    process.exit(1);
+}

package/test/multiContextCacheSimple.test.js

@@ -0,0 +1,185 @@
+/**
+ * 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);
+}