sqlcache 2.9.0 → 2.9.1

package/docs/EXAMPLES.md

@@ -2,6 +2,19 @@
 
 Comprehensive examples for common use cases.
 
+Most examples omit cache names and invalidation prefixes, so they assume both automatic features are
+on:
+
+```bash
+# .env
+CORE_AUTO_FEATURES=true       # automatic cache keys: cacheName may be omitted
+CORE_AUTO_INVALIDATION=true   # automatic invalidation: writes without resetCacheName clear <table>:* and <table>_*
+```
+
+Without `CORE_AUTO_FEATURES`, a call without a cache name throws `cacheName is required...`; without
+`CORE_AUTO_INVALIDATION`, a write without `resetCacheName` clears nothing. The handlers are
+Express-style, with `app`, `req` and `res` defined by your application.
+
 ---
 
 ## Table of Contents
@@ -41,11 +54,11 @@ app.post('/orders', async (req, res) => {
 
             // 2. Process each item
             for (const item of items) {
-                // Check stock
-                const [product] = await tx.getCacheQuery(
-                    'SELECT id, name, price, stock FROM products WHERE id = ?',
-                    [item.productId],
-                    `product-${item.productId}`
+                // Check stock: read and lock the row inside the transaction, never from the
+                // cache (a cached stock level can be hours old)
+                const [product] = await tx.query(
+                    'SELECT id, name, price, stock FROM products WHERE id = ? FOR UPDATE',
+                    [item.productId]
                 );
 
                 if (!product || product.stock < item.quantity) {
@@ -58,7 +71,7 @@ app.post('/orders', async (req, res) => {
                     [orderId, item.productId, item.quantity, product.price]
                 );
 
-                // Update stock
+                // Update stock (products:* and products_* are cleared after the commit)
                 await tx.query(
                     'UPDATE products SET stock = stock - ? WHERE id = ?',
                     [item.quantity, item.productId]
@@ -94,7 +107,9 @@ app.post('/orders', async (req, res) => {
 ### Product Catalog with Caching
 
 ```javascript
-// Get products by category (cached)
+// Get products by category (cached under products:category_id:status:<hash>)
+// Only the first table counts for keys and invalidation: when a category is renamed,
+// pass 'products:' as resetCacheName so these listings are refreshed.
 app.get('/products/category/:categoryId', async (req, res) => {
     const { categoryId } = req.params;
     const { page = 1, limit = 20 } = req.query;
@@ -121,7 +136,7 @@ app.put('/products/:id', async (req, res) => {
         'UPDATE products SET name = ?, price = ?, stock = ?, category_id = ? WHERE id = ?',
         [name, price, stock, category_id, id]
     );
-    // ✅ All product caches automatically cleared
+    // ✅ products:* and products_* automatically cleared (CORE_AUTO_INVALIDATION=true)
 
     res.json({ success: true });
 });
@@ -237,13 +252,18 @@ app.post('/posts/:id/like', async (req, res) => {
 ### Tenant Database Switching
 
 ```javascript
-// Middleware to get tenant database
+const bcrypt = require('bcrypt'); // or another password-hashing library
+
+// Middleware to get the tenant database: take the tenant from the authenticated session
+// (set by your auth middleware) and check it against an allowlist, never from a raw header
+const TENANT_DATABASES = new Set(['tenant_1', 'tenant_2', 'tenant_3']);
+
 const getTenantDb = (req, res, next) => {
-    const tenantId = req.headers['x-tenant-id'];
-    if (!tenantId) {
-        return res.status(400).json({ error: 'Tenant ID required' });
+    const tenantDb = req.user && `tenant_${req.user.tenantId}`;
+    if (!tenantDb || !TENANT_DATABASES.has(tenantDb)) {
+        return res.status(403).json({ error: 'Unknown tenant' });
     }
-    req.tenantDb = `tenant_${tenantId}`;
+    req.tenantDb = tenantDb;
     next();
 };
 
@@ -252,20 +272,23 @@ app.get('/users', getTenantDb, async (req, res) => {
     const users = await getCacheQuery(
         'SELECT id, name, email, role, created_at FROM users WHERE status = ?',
         ['active'],
-        null,  // Auto-generated cache key
+        null,  // Auto-generated cache key, ends with @<tenant database>
         req.tenantDb  // Tenant-specific database
     );
 
     res.json(users);
 });
 
-// Create user in tenant database
-app.post('/users', getTenantDb, async (req, res) => {
-    const { name, email, password, role } = req.body;
+// Create user in tenant database (requireAdmin: your own authorization middleware)
+app.post('/users', getTenantDb, requireAdmin, async (req, res) => {
+    const { name, email, password } = req.body;
+    // Never take a role from the request as-is, and never store a plain-text password
+    const role = ['member', 'editor'].includes(req.body.role) ? req.body.role : 'member';
+    const passwordHash = await bcrypt.hash(password, 10);
 
     const result = await QuaryCache(
         'INSERT INTO users (name, email, password, role, created_at) VALUES (?, ?, ?, ?, NOW())',
-        [name, email, password, role],
+        [name, email, passwordHash, role],
         null,  // Auto-invalidation
         req.tenantDb
     );
@@ -278,21 +301,30 @@ app.post('/users', getTenantDb, async (req, res) => {
 
 ```javascript
 app.get('/dashboard/stats', getTenantDb, async (req, res) => {
+    const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+
     const stats = await withTransaction(async (tx) => {
-        // Get multiple stats in parallel
+        // Several stats, one after another (a transaction runs on one connection).
+        // Aggregates get explicit cache names: an automatic key would be users:all@<db>, the same
+        // as for any other query on the table without a WHERE clause. Names under the
+        // '<table>:' prefix are still cleared by automatic invalidation.
         const [userStats] = await tx.getCacheQuery(
             'SELECT COUNT(*) as total, SUM(CASE WHEN status="active" THEN 1 ELSE 0 END) as active FROM users',
-            []
+            [],
+            `users:stats@${req.tenantDb}`
         );
 
+        // The day is a parameter and part of the name, so yesterday's entry is not reused
         const [orderStats] = await tx.getCacheQuery(
-            'SELECT COUNT(*) as total, SUM(total_amount) as revenue FROM orders WHERE DATE(created_at) = CURDATE()',
-            []
+            'SELECT COUNT(*) as total, SUM(total_amount) as revenue FROM orders WHERE created_at >= ? AND created_at < ? + INTERVAL 1 DAY',
+            [today, today],
+            `orders:stats:${today}@${req.tenantDb}`
         );
 
         const [productStats] = await tx.getCacheQuery(
             'SELECT COUNT(*) as total, SUM(CASE WHEN stock < 10 THEN 1 ELSE 0 END) as low_stock FROM products',
-            []
+            [],
+            `products:stats@${req.tenantDb}`
         );
 
         return {
@@ -319,9 +351,12 @@ const { bulkInsert } = require('sqlcache');
 app.post('/analytics/events/bulk', async (req, res) => {
     const events = req.body.events; // Array of events
 
-    // Add timestamps
+    // Map each event onto a fixed set of columns: bulkInsert uses the keys of the first
+    // record as column names, so never pass request objects (or spread them) as they are
     const enrichedEvents = events.map(event => ({
-        ...event,
+        event_type: String(event.type),
+        user_id: event.userId,
+        data: JSON.stringify(event.data),
         created_at: new Date(),
         ip_address: req.ip
     }));
@@ -459,6 +494,9 @@ app.post('/chat/rooms/:roomId/read', async (req, res) => {
 ### User Registration with Transaction
 
 ```javascript
+const bcrypt = require('bcrypt'); // or another password-hashing library
+const { withTransaction } = require('sqlcache');
+
 app.post('/auth/register', async (req, res) => {
     const { email, password, name } = req.body;
 
@@ -508,16 +546,19 @@ app.post('/auth/register', async (req, res) => {
 ### Session Management
 
 ```javascript
-const { addArrayItem, getArrayItem, delKeyItem } = require('sqlcache');
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const { QuaryCache, addArrayItem, getArrayItem, delKeyItem } = require('sqlcache');
 
 // Create session
 app.post('/auth/login', async (req, res) => {
     const { email, password } = req.body;
 
-    const [user] = await getCacheQuery(
+    // Read credentials from MySQL, not through the cache: a cached password hash would keep an
+    // old password valid until the entry expires (QuaryCache neither reads the cache nor stores results)
+    const [user] = await QuaryCache(
         'SELECT id, email, password, name FROM users WHERE email = ?',
-        [email],
-        `user-email-${email}`
+        [email]
     );
 
     if (!user || !(await bcrypt.compare(password, user.password))) {

package/docs/MIGRATION.md

@@ -1,6 +1,83 @@
 # Migration Guide
 
-Guide for migrating to v2.6.0 and adopting smart features.
+Guide for upgrading between sqlcache versions and adopting the automatic features.
+
+---
+
+## v2.9.0 → v2.9.1
+
+A patch release. The API is unchanged; some TypeScript types accept more than before. The
+differences:
+
+### Requirements
+
+- Node.js 14 or newer (tested on 18–26); `engines.node` is `>=14`.
+- mysql2 3.23.1 or newer (the dependency is now `^3.23.1`). Older versions have security
+  advisories, including critical ones; update lockfiles that pin an older mysql2.
+
+### Imports
+
+- Named ESM imports work: `import { getCacheQuery } from 'sqlcache'`. On 2.9.0 and earlier, native
+  ESM could only import `QuaryCache` by name; use the default import there.
+- `import sqlcache from 'sqlcache'` works without `esModuleInterop`: the module now has a
+  non-enumerable `default` property, as the type definitions always declared.
+- Types: `QuaryCache<T>()` takes the result type (default `QueryResult`, which gained `info` and
+  `warningStatus`); `resetCacheName` accepts `string[]` in `QuaryCache` and `bulkInsert`; `parameters`
+  is optional except in `getCacheQueryPagination`; the cache name may be omitted in
+  `getCacheQueryWithTimeout` and passed as `null` to `getCacheQueryPagination`; a `withTransaction`
+  callback may return a plain value; `configure`, `enableAutoKey` and `enableAutoInvalidation` accept
+  booleans.
+
+### Caching
+
+- Empty results are no longer written to the cache; they were never served from it.
+- A cached value that is not a non-empty array is treated as a miss. For pagination, it must be a
+  page object.
+- A read that started before an invalidation in the same process no longer writes its possibly stale
+  result to the cache. Across processes a short window remains.
+- `tx.getCacheQuery` still reads the cache first, but writes to it only after the transaction commits.
+  Nothing is cached from a rolled-back transaction.
+- `getCacheQueryPagination` and `getCacheQueryWithTimeout` without a cache name use an automatic key
+  when automatic keys are enabled; otherwise the result is not cached and a one-time warning is
+  logged. Before 2.9.1 all such calls shared one cache key.
+- Automatic keys of queries without a detectable table (`CALL`, `SELECT fn(?)`) now include the
+  parameters: `query:<sqlhash>:<paramhash>`. `BigInt` parameters no longer throw.
+- New `DB_COALESCE_MAX_WAIT` (ms, default 10000): how long concurrent cache misses wait for a shared
+  query before starting a fresh one, which protects against a stuck connection. A waiting caller
+  still takes the original result if it arrives first. When a shared query fails with
+  `ER_QUERY_TIMEOUT` (`MAX_EXECUTION_TIME`), that error goes to every caller waiting on it.
+
+### Turning features off
+
+- `enableAutoKey(false)`, `enableAutoInvalidation(false)` and `configure({ autoKey: false })` now
+  disable the feature. Before 2.9.1 they enabled it; check calls that pass `false`.
+
+### bulkInsert
+
+- Invalid table or column names are rejected before anything is sent, with a `TypeError`:
+  `bulkInsert: invalid table name "<name>"` or `bulkInsert: invalid column name "<name>"`. Valid names
+  are unchanged.
+- Auto-invalidation (`CORE_AUTO_INVALIDATION` / `enableAutoInvalidation`) now also applies to
+  `bulkInsert` when no `resetCacheName` is given.
+- Invalidation also runs when `bulkInsert` fails after rows may have been written.
+- With `transaction: true`, an error from `COMMIT` is not retried and carries
+  `err.commitOutcomeUnknown = true`.
+
+### Queries and connections
+
+- `cancelOnTimeout`: the connection whose query was killed is discarded instead of being returned to
+  the pool, at most 4 cancellations run at once, and a timeout during the database switch also stops
+  the query from being sent.
+- Pagination appends `LIMIT` on a new line, so SQL ending in a `-- comment` paginates correctly.
+- `DROP DATABASE` / `DROP SCHEMA` in your SQL is handled like `USE`: the next call on that pooled
+  connection selects its database again.
+
+### Redis
+
+- `isRedisConnected()` returns `false` without opening a connection when `REDIS_ENABLED=false`.
+- One log line per reconnect attempt: `Redis reconnecting... (attempt N, delay Xms)`.
+- A log line appears if more than 1000 invalidations are missed during an outage.
+- A one-time warning appears if `REDIS_VHOST` changes at runtime.
 
 ---
 
@@ -52,9 +129,10 @@ app.post('/users', async (req, res) => {
 const { getCacheQuery, QuaryCache } = require('sqlcache');
 
 // .env
-CORE_AUTO_FEATURES=true
+CORE_AUTO_FEATURES=true       // automatic cache keys
+CORE_AUTO_INVALIDATION=true   // automatic invalidation (CORE_AUTO_FEATURES alone does not enable it)
 
-// Read with auto-cache
+// Read with auto-cache (key users:id:<hash>)
 app.get('/users/:id', async (req, res) => {
     const users = await getCacheQuery('SELECT * FROM users WHERE id = ?', [req.params.id]);
     res.json(users[0]);
@@ -63,16 +141,19 @@ app.get('/users/:id', async (req, res) => {
 // Write with auto-invalidation
 app.post('/users', async (req, res) => {
     await QuaryCache('INSERT INTO users (name, email) VALUES (?, ?)', [req.body.name, req.body.email]);
-    // ✅ All user caches automatically cleared!
+    // ✅ users:* and users_* automatically cleared
     res.json({ success: true });
 });
 ```
 
 **Benefits:**
 - 10+ lines → 3 lines
-- No cache key management
-- No manual invalidation
-- No forgotten keys
+- No cache key management for simple queries
+- No manual invalidation for writes to the cached table
+
+Automatic keys and invalidation follow the first table of each statement only; see the README's
+[Cache keys and invalidation](../README.md#cache-keys-and-invalidation) for what needs an explicit
+cache name or `resetCacheName` (joins, aggregates, `CALL`, writes from other applications, ...).
 
 ---
 
@@ -95,8 +176,8 @@ const [users] = await pool.query('SELECT * FROM users WHERE id = ?', [123]);
 // After
 const { getCacheQuery } = require('sqlcache');
 
-const users = await getCacheQuery('SELECT * FROM users WHERE id = ?', [123]);
-// ✅ Same API + automatic caching!
+const users = await getCacheQuery('SELECT * FROM users WHERE id = ?', [123], 'user:123');
+// ✅ Same SQL and parameters + automatic caching; returns the rows directly (no [rows, fields])
 ```
 
 ### From `knex`
@@ -118,13 +199,15 @@ const users = await knex('users').where('id', 123).select('*');
 // After
 const { getCacheQuery } = require('sqlcache');
 
-const users = await getCacheQuery('SELECT * FROM users WHERE id = ?', [123]);
+const users = await getCacheQuery('SELECT * FROM users WHERE id = ?', [123], 'user:123');
 ```
 
 ---
 
 ## Version Migration
 
+For v2.9.0 → v2.9.1 see [the top of this guide](#v290--v291).
+
 ### Package renamed to `sqlcache` (v2.9.0)
 
 From v2.9.0 the package is published as `sqlcache`; the API is unchanged.
@@ -144,7 +227,8 @@ const { getCacheQuery } = require('sqlcache');
 Deep imports (`/dbConnector`, `/redis.Connector`, `/core/...`) and TypeScript imports change the same
 way. You do not have to switch right away: `node-caching-mysql-connector-with-redis@2.9.0` only
 forwards to `sqlcache@^2.9.0` (including those deep paths and the types), so `npm update` on the old
-name already runs the same code. The old name is deprecated and gets no new major versions.
+name already runs the same code. The old name is deprecated and gets no new major versions. Deep
+imports have no type declarations of their own; TypeScript code should import from `'sqlcache'`.
 
 ### v2.8.x → v2.9.0 (performance & resilience)
 
@@ -181,14 +265,17 @@ can be switched back with an environment variable.
   they write to (previously no table, or a wrong one).
 - **`bulkInsert` no longer re-inserts committed chunks** when a connection error triggers a retry.
 - **`closeConnections()` no longer hangs the process.** With mysql2 3.3.x the pool's idle reaper
-  kept running after `end()` and later spun in a synchronous loop at 100% CPU.
+  kept running after `end()` and later spun in a synchronous loop at 100% CPU. It closes only the
+  MySQL pool: with Redis enabled, also call `getRedisClient().quit()`, or the open Redis connection
+  keeps the process alive.
 - **The Redis client really never stops reconnecting.** node-redis gave up after one hour of retries,
   leaving the cache disabled until a restart.
 - **Invalidations missed during a Redis outage are replayed** when Redis is ready again, instead of
   leaving stale entries for the rest of their TTL.
 - A failed command sent without a callback through `getRedisClient()` no longer marks Redis as down.
 - `REDIS_ENABLED=false` no longer opens a Redis connection (and reconnect loop) at startup; it is
-  opened on the first direct Redis call, including `isRedisConnected()`.
+  opened on the first direct Redis call, including `isRedisConnected()` (no longer the case for
+  `isRedisConnected()` since v2.9.1).
 - An empty `REDIS_PASSWORD` no longer sends `AUTH ""`.
 
 #### Smaller observable differences (no switch)
@@ -224,6 +311,8 @@ return the same results with less work.
 ### v2.5.x → v2.6.0
 
 #### What's New
+- Automatic cache keys and invalidation, opt-in (`CORE_AUTO_FEATURES`, `CORE_AUTO_INVALIDATION`,
+  `configure()`, `enableAutoKey()`, `enableAutoInvalidation()`)
 - Transaction support (`withTransaction`)
 - Enhanced documentation
 - More comprehensive tests
@@ -241,7 +330,7 @@ return the same results with less work.
 2. **No code changes required**
    ```javascript
    // Your v2.5.x code works exactly the same
-   await getCacheQuery('SELECT * FROM users', [], 'users-all');
+   await getCacheQuery('SELECT * FROM users', [], 'users_all');
    await QuaryCache('INSERT INTO users...', [data], 'users_*');
    ```
 
@@ -256,6 +345,7 @@ return the same results with less work.
        await connection.commit();
    } catch (error) {
        await connection.rollback();
+       throw error;
    } finally {
        connection.release();
    }
@@ -280,21 +370,27 @@ npm install sqlcache
 // Use with manual keys (no changes to existing logic)
 const { getCacheQuery, QuaryCache } = require('sqlcache');
 
-await getCacheQuery('SELECT * FROM users', [], 'users-all');
-await QuaryCache('INSERT INTO users...', [data], 'users_*');
+await getCacheQuery('SELECT * FROM users', [], 'users_all');
+await QuaryCache('INSERT INTO users...', [data], 'users_*'); // clears users_all
 ```
 
 ### Phase 2: Enable Auto Features
 
 ```javascript
 // .env
-CORE_AUTO_FEATURES=true
+CORE_AUTO_FEATURES=true       // automatic keys
+CORE_AUTO_INVALIDATION=true   // automatic invalidation (not enabled by CORE_AUTO_FEATURES)
 
 // Remove cache keys from new code
-await getCacheQuery('SELECT * FROM users', []); // Auto key ✨
+await getCacheQuery('SELECT * FROM users', []); // Auto key users:all ✨
 
 // Old code with manual keys still works
-await getCacheQuery('SELECT * FROM orders', [], 'orders-all'); // Manual key
+await getCacheQuery('SELECT * FROM orders', [], 'orders_all'); // Manual key
+
+// But a resetCacheName replaces the automatic patterns, so old writes that clear only
+// 'users_*' leave the new users:... keys stale. Drop the resetCacheName from such writes,
+// or clear both prefixes:
+await QuaryCache('INSERT INTO users...', [data], ['users_', 'users:']);
 ```
 
 ### Phase 3: Adopt Transactions
@@ -312,14 +408,17 @@ await withTransaction(async (tx) => {
 
 ```javascript
 // Before
-await getCacheQuery('SELECT * FROM users', [], 'users-all');
-await getCacheQuery('SELECT * FROM posts', [], 'posts-recent');
+await getCacheQuery('SELECT * FROM users', [], 'users_all');
+await getCacheQuery('SELECT * FROM posts', [], 'posts_recent');
 
 // After (once confident in auto features)
 await getCacheQuery('SELECT * FROM users', []);
 await getCacheQuery('SELECT * FROM posts', []);
 ```
 
+Keep explicit names where automatic keys would collide, such as aggregates, joins and
+`LIMIT`/`ORDER BY` variants (see the README's caveats).
+
 ---
 
 ## Common Migration Scenarios
@@ -342,7 +441,7 @@ app.get('/users', async (req, res) => {
 const { getCacheQuery } = require('sqlcache');
 
 app.get('/users', async (req, res) => {
-    const users = await getCacheQuery('SELECT * FROM users', []);
+    const users = await getCacheQuery('SELECT * FROM users', []); // auto key users:all (CORE_AUTO_FEATURES=true)
     res.json(users);
 });
 ```
@@ -365,11 +464,12 @@ async function processOrders() {
 const { QuaryCache } = require('sqlcache');
 
 async function processOrders() {
-    const orders = await getCacheQuery('SELECT * FROM orders WHERE status = ?', ['pending']);
+    // A work queue must see the current rows: QuaryCache reads MySQL without the cache
+    const orders = await QuaryCache('SELECT * FROM orders WHERE status = ?', ['pending']);
     
     for (const order of orders) {
         await QuaryCache('UPDATE orders SET status = ? WHERE id = ?', ['processing', order.id]);
-        // ✅ Caches automatically cleared
+        // ✅ orders:* and orders_* cleared (CORE_AUTO_INVALIDATION=true)
     }
 }
 ```
@@ -408,7 +508,8 @@ async function createUserWithProfile(userData, profileData) {
         const userResult = await tx.query('INSERT INTO users...', [userData]);
         await tx.query('INSERT INTO profiles...', [userResult.insertId, profileData]);
         return userResult.insertId;
-        // ✅ Auto commit, auto rollback, auto cache invalidation
+        // ✅ Auto commit, auto rollback, cache invalidation after the commit
+        //    (automatic with CORE_AUTO_INVALIDATION=true, or pass resetCacheName to tx.query)
     });
 }
 ```
@@ -433,7 +534,7 @@ const { getCacheQuery } = require('sqlcache');
 
 describe('User API', () => {
     it('should fetch users with cache', async () => {
-        const users = await getCacheQuery('SELECT * FROM users', []);
+        const users = await getCacheQuery('SELECT * FROM users', [], 'users_all');
         expect(users).to.be.an('array');
     });
 });
@@ -441,12 +542,16 @@ describe('User API', () => {
 
 ### Integration Tests
 
+`REDIS_ENABLED`, like the pool and coalescing settings, is read once, when sqlcache is first
+required. Changing it afterwards has no effect, so set it before the first `require` and run the
+Redis and no-Redis variants as separate test processes:
+
 ```javascript
-// Test with Redis enabled
+// test/setup-redis.js (one test run)
 process.env.REDIS_ENABLED = 'true';
 process.env.CORE_AUTO_FEATURES = 'true';
 
-// Test without Redis (fallback)
+// test/setup-no-redis.js (another test run): MySQL only, no caching
 process.env.REDIS_ENABLED = 'false';
 ```
 
@@ -459,11 +564,12 @@ If you need to rollback:
 1. **Disable auto features**
    ```bash
    CORE_AUTO_FEATURES=false
+   CORE_AUTO_INVALIDATION=false
    ```
 
 2. **Add manual keys back**
    ```javascript
-   await getCacheQuery('SELECT * FROM users', [], 'users-all');
+   await getCacheQuery('SELECT * FROM users', [], 'users_all');
    await QuaryCache('INSERT INTO users...', [data], 'users_*');
    ```
 
@@ -478,23 +584,17 @@ If you need to rollback:
 
 ### Before Migration
 
-- Manual cache management: ~50ms per request
 - Risk of stale data due to missed invalidations
 - Complex code maintenance
 
 ### After Migration
 
-- Auto cache: ~2ms overhead
-- Guaranteed cache consistency
-- Simpler code (80% less boilerplate)
-
-### Benchmark
-
-```javascript
-// Manual approach: 10 lines, 50ms
-// Auto approach: 2 lines, 52ms
-// Trade-off: +2ms for huge DX improvement ✅
-```
+- Cache hits are served from Redis; a miss adds a Redis read to the query, and a Redis write when
+  the result is not empty
+- Invalidation is automatic for writes made through sqlcache to the first table of each statement;
+  joins, aggregates, `CALL`, writes from other applications and the cases listed in the README still
+  need explicit cache names or `resetCacheName`
+- Simpler code
 
 ---
 
@@ -502,7 +602,6 @@ If you need to rollback:
 
 - **Documentation**: [API Reference](API.md) | [Examples](EXAMPLES.md)
 - **Issues**: [GitHub Issues](https://github.com/hayatialikeles/sqlcache/issues)
-- **Community**: [Discussions](https://github.com/hayatialikeles/sqlcache/discussions)
 
 ---