@nina-protocol/nina-db 0.0.111 → 0.0.112

package/dist/models/Account.js

@@ -4,7 +4,7 @@ import Hub from './Hub.js';
 import Post from './Post.js';
 import Release from './Release.js';
 import Verification from './Verification.js';
-import Subscription from './Subscription.js';
+import SubscriptionsWithCache from '../redis/subscriptions.js';
 export default class Account extends Model {
     static tableName = 'accounts';
     static idColumn = 'id';
@@ -37,9 +37,8 @@ export default class Account extends Model {
             this.verifications = verifications;
         }
         delete this.id;
-        // Use count() instead of range(0,0) to avoid temporary object creation
-        const followersCount = await Subscription.query().where('to', this.publicKey).count('* as count').first();
-        this.followers = parseInt(followersCount.count);
+        const followersCount = await SubscriptionsWithCache.getFollowCountForAccountWithCache(this.publicKey, false);
+        this.followers = followersCount;
     };
     static relationMappings = () => ({
         published: {

package/dist/models/Hub.js

@@ -3,7 +3,7 @@ import { stripHtmlIfNeeded } from '../utils/index.js';
 import Account from './Account.js';
 import Release from './Release.js';
 import Post from './Post.js';
-import Subscription from './Subscription.js';
+import SubscriptionsWithCache from '../redis/subscriptions.js';
 export default class Hub extends Model {
     static get tableName() {
         return 'hubs';
@@ -31,9 +31,8 @@ export default class Hub extends Model {
         delete this.authorityId;
         delete this.id;
         stripHtmlIfNeeded(this.data, 'description');
-        // Use count() instead of range(0,0) to avoid temporary object creation
-        const followersCount = await Subscription.query().where('to', this.publicKey).count('* as count').first();
-        this.followers = parseInt(followersCount.count);
+        const followersCount = await SubscriptionsWithCache.getFollowCountForAccountWithCache(this.publicKey, true);
+        this.followers = followersCount;
     }
     static relationMappings = () => ({
         authority: {

package/dist/redis/subscriptions.js

@@ -99,13 +99,51 @@ const deleteCacheAfterAccountFollow = async (toPublicKey, toHandle, fromPublicKe
         await redis.deleteCacheMatchingPattern(`following:${fromPublicKey}:${toHandle}`);
         await redis.deleteCacheMatchingPattern(`following:${fromHandle}:${toPublicKey}`);
         await redis.deleteCacheMatchingPattern(`following:${fromHandle}:${toHandle}`);
+        await redis.deleteCacheMatchingPattern(`${SUBSCRIPTION_TO}:count:${toPublicKey}`);
+        await redis.deleteCacheMatchingPattern(`${SUBSCRIPTION_TO}:count:${toHandle}`);
     }
     catch (error) {
         console.log('deleteCacheAfterAccountFollow error: ', error);
     }
 };
+const getFollowCountForAccountWithCache = async (publicKeyOrHandle, isHub = false, override = false) => {
+    try {
+        let dbRecord = null;
+        return redis.withCache(`${SUBSCRIPTION_TO}:count:${publicKeyOrHandle}`, async () => {
+            if (isHub) {
+                dbRecord = await Hub.query().findOne({ publicKey: publicKeyOrHandle });
+                if (!dbRecord) {
+                    dbRecord = await Hub.query().findOne({ handle: publicKeyOrHandle });
+                    if (!dbRecord) {
+                        throw new Error(`Hub not found for publicKeyOrHandle ${publicKeyOrHandle}`);
+                    }
+                }
+            }
+            else {
+                dbRecord = await Account.query().findOne({ publicKey: publicKeyOrHandle });
+                if (!dbRecord) {
+                    dbRecord = await Account.query().findOne({ handle: publicKeyOrHandle });
+                    if (!dbRecord) {
+                        throw new Error(`Account not found for publicKeyOrHandle ${publicKeyOrHandle}`);
+                    }
+                }
+            }
+            if (dbRecord) {
+                const count = await Subscription.query().where('to', dbRecord.publicKey).count('* as count').first();
+                return parseInt(count.count);
+            }
+            else {
+                return 0;
+            }
+        }, undefined, override);
+    }
+    catch (error) {
+        console.log('getFollowCountForAccountWithCache error: ', error);
+    }
+};
 export default {
     getFollowersForAccountWithCache,
     getUserFollowingAccountWithCache,
     deleteCacheAfterAccountFollow,
+    getFollowCountForAccountWithCache,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nina-protocol/nina-db",
-  "version": "0.0.111",
+  "version": "0.0.112",
   "description": "",
   "source": "src/index.js",
   "main": "dist/index.js",

package/src/models/Account.js

@@ -4,7 +4,7 @@ import Hub from './Hub.js';
 import Post from './Post.js';
 import Release from './Release.js';
 import Verification from './Verification.js';
-import Subscription from './Subscription.js';
+import SubscriptionsWithCache from '../redis/subscriptions.js';
 
 export default class Account extends Model {
   static tableName= 'accounts';
@@ -42,9 +42,9 @@ export default class Account extends Model {
       this.verifications = verifications;
     }
     delete this.id
-    // Use count() instead of range(0,0) to avoid temporary object creation
-    const followersCount = await Subscription.query().where('to', this.publicKey).count('* as count').first();
-    this.followers = parseInt(followersCount.count);
+
+    const followersCount = await SubscriptionsWithCache.getFollowCountForAccountWithCache(this.publicKey, false);
+    this.followers = followersCount;
   }
 
   static relationMappings = () => ({    

package/src/models/Hub.js

@@ -3,7 +3,7 @@ import { stripHtmlIfNeeded } from '../utils/index.js';
 import Account from './Account.js';
 import Release from './Release.js';
 import Post from './Post.js';
-import Subscription from './Subscription.js';
+import SubscriptionsWithCache from '../redis/subscriptions.js';
 
 export default class Hub extends Model {
   static get tableName() {
@@ -35,9 +35,8 @@ export default class Hub extends Model {
 
     stripHtmlIfNeeded(this.data, 'description');
 
-    // Use count() instead of range(0,0) to avoid temporary object creation
-    const followersCount = await Subscription.query().where('to', this.publicKey).count('* as count').first();
-    this.followers = parseInt(followersCount.count);
+    const followersCount = await SubscriptionsWithCache.getFollowCountForAccountWithCache(this.publicKey, true);
+    this.followers = followersCount;
   }
   
   static relationMappings = () => ({

package/src/redis/subscriptions.js

@@ -120,14 +120,50 @@ const deleteCacheAfterAccountFollow = async(
     await redis.deleteCacheMatchingPattern(`following:${fromPublicKey}:${toHandle}`)
     await redis.deleteCacheMatchingPattern(`following:${fromHandle}:${toPublicKey}`)
     await redis.deleteCacheMatchingPattern(`following:${fromHandle}:${toHandle}`)
-    
+    await redis.deleteCacheMatchingPattern(`${SUBSCRIPTION_TO}:count:${toPublicKey}`)
+    await redis.deleteCacheMatchingPattern(`${SUBSCRIPTION_TO}:count:${toHandle}`)
   } catch (error) {
     console.log('deleteCacheAfterAccountFollow error: ', error)
   }
 }
 
+const getFollowCountForAccountWithCache = async (publicKeyOrHandle, isHub=false, override=false) => {
+  try {
+    let dbRecord = null;
+    return redis.withCache(`${SUBSCRIPTION_TO}:count:${publicKeyOrHandle}`, async () => {
+      if (isHub) {
+        dbRecord = await Hub.query().findOne({publicKey: publicKeyOrHandle});
+        if (!dbRecord) {
+          dbRecord = await Hub.query().findOne({handle: publicKeyOrHandle});
+          if (!dbRecord) {
+            throw new Error(`Hub not found for publicKeyOrHandle ${publicKeyOrHandle}`)
+          }
+        }
+      } else {
+        dbRecord = await Account.query().findOne({publicKey: publicKeyOrHandle});
+        if (!dbRecord) {
+          dbRecord = await Account.query().findOne({handle: publicKeyOrHandle});
+          if (!dbRecord) {
+            throw new Error(`Account not found for publicKeyOrHandle ${publicKeyOrHandle}`)
+          }
+        }
+      }
+      
+      if (dbRecord) {
+        const count = await Subscription.query().where('to', dbRecord.publicKey).count('* as count').first();
+        return parseInt(count.count);
+      } else {
+        return 0;
+      }
+    }, undefined, override)
+  } catch (error) {
+    console.log('getFollowCountForAccountWithCache error: ', error)
+  }
+}
+
 export default {
   getFollowersForAccountWithCache,
   getUserFollowingAccountWithCache,
   deleteCacheAfterAccountFollow,
+  getFollowCountForAccountWithCache,
 }