Added .isDisabled() method to the Limit Service (#550)

ref https://linear.app/ghost/issue/PROD-2172

- Limits such as `FlagLimit` are calculated solely based on their `disabled` boolean field
- The Limit Service only exposes async methods such as `checkWouldGoOverLimit`, which forces downstream methods in e.g. Ghost to be async too
- The new `.isDisabled()` sync method returns true/false based on the value of the `disabled` field, or throws an error if the limit does not support a `disabled` field

Author: sagzy

packages/limit-service/README.md

@@ -68,8 +68,12 @@ const limits = {
         error: 'Your plan supports uploads of max size up to {{max}}. Please upgrade to reenable uploading.'
     },
     limitStripeConnect: {},
-    limitAnalytics: {},
-    limitSocialWeb: {}
+    limitAnalytics: {
+        disabled: false
+    },
+    limitSocialWeb: {
+        disabled: true
+    }
 };
 
 // This information is needed for the limit service to work with "max periodic" limits
@@ -134,6 +138,16 @@ if (limitService.isLimited('uploads')) {
     await limitService.errorIfIsOverLimit('uploads', {currentCount: frame.file.size});
 }
 
+// Limits expose an async `checkWouldGoOverLimit` method, which can be used to check whether a limit has been reached, but not throw an error:
+if (await limitService.checkWouldGoOverLimit('members')) {
+    console.log('Members limit has been reached!');
+}
+
+// Flag limits additionally expose a `isDisabled` sync check, which can be used instead of the async `checkWouldGoOverLimit`:
+if (limitService.isDisabled('limitSocialWeb')) {
+    console.log('Social web is disabled by config!'));
+}
+
 // check if any of the limits are acceding
 if (limitService.checkIfAnyOverLimit()) {
     console.log('One of the limits has acceded!');

packages/limit-service/lib/LimitService.js

@@ -69,6 +69,27 @@ class LimitService {
         return !!this.limits[camelCase(limitName)];
     }
 
+    /**
+    * Check if a limit is disabled, applicable only to limits that support the disabled flag (e.g. FlagLimit)
+    * @returns {boolean|undefined} undefined if limit is not configured
+    * @throws {IncorrectUsageError} if limit does not support disabled flag
+    */
+    isDisabled(limitName) {
+        if (!this.isLimited(limitName)) {
+            return;
+        }
+
+        const limit = this.limits[camelCase(limitName)];
+
+        if (typeof limit.isDisabled !== 'function') {
+            throw new IncorrectUsageError({
+                message: `Limit ${limitName} does not support .isDisabled()`
+            });
+        }
+
+        return limit.isDisabled();
+    }
+
     /**
      *
      * @param {String} limitName - name of the configured limit

packages/limit-service/lib/limit.js

@@ -303,6 +303,14 @@ class FlagLimit extends Limit {
     async errorIfIsOverLimit() {
         return;
     }
+
+    /**
+     * Checks whether the Flag limit is disabled or not
+     * @returns boolean
+     */
+    isDisabled() {
+        return !!this.disabled;
+    }
 }
 
 class AllowlistLimit extends Limit {

packages/limit-service/test/LimitService.test.js

@@ -2,6 +2,7 @@
 // const testUtils = require('./utils');
 require('./utils');
 const should = require('should');
+const assert = require('node:assert').strict;
 const LimitService = require('../lib/LimitService');
 const {MaxLimit, MaxPeriodicLimit, FlagLimit} = require('../lib/limit');
 const sinon = require('sinon');
@@ -544,4 +545,58 @@ describe('Limit Service', function () {
             sinon.assert.alwaysCalledWithExactly(maxPeriodSpy, options);
         });
     });
+
+    describe('isDisabled', function () {
+        it('returns undefined if limit is not configured', function () {
+            const limitService = new LimitService();
+
+            assert.equal(limitService.isDisabled('test'), undefined);
+        });
+
+        it('throws if the limit does not implement .isDisabled()', function () {
+            const limitService = new LimitService();
+
+            let limits = {
+                staff: {
+                    max: 2,
+                    currentCountQuery: () => 1
+                }
+            };
+
+            limitService.loadLimits({limits, errors});
+
+            try {
+                limitService.isDisabled('staff');
+                assert.fail('Should have thrown an error');
+            } catch (err) {
+                assert.equal(err.message, `Limit staff does not support .isDisabled()`);
+            }
+        });
+
+        it('returns true if the limit is disabled', function () {
+            const limitService = new LimitService();
+
+            let limits = {
+                limitSocialWeb: {
+                    disabled: true
+                }
+            };
+
+            limitService.loadLimits({limits, errors});
+            assert.equal(limitService.isDisabled('limitSocialWeb'), true);
+        });
+
+        it('returns false if the limit is not disabled', function () {
+            const limitService = new LimitService();
+
+            let limits = {
+                limitSocialWeb: {
+                    disabled: false
+                }
+            };
+
+            limitService.loadLimits({limits, errors});
+            assert.equal(limitService.isDisabled('limitSocialWeb'), false);
+        });
+    });
 });

packages/limit-service/test/limit.test.js

@@ -3,11 +3,12 @@
 require('./utils');
 const should = require('should');
 const sinon = require('sinon');
+const assert = require('node:assert').strict;
 
 const errors = require('./fixtures/errors');
 const {MaxLimit, AllowlistLimit, FlagLimit, MaxPeriodicLimit} = require('../lib/limit');
 
-describe('Limit Service', function () {
+describe('Limit', function () {
     describe('Flag Limit', function () {
         it('do nothing if is over limit', async function () {
             // NOTE: the behavior of flag limit in "is over limit" use case is flawed and should not be relied on
@@ -43,6 +44,35 @@ describe('Limit Service', function () {
                 should.equal(err.message, 'Your plan does not support flaggy. Please upgrade to enable flaggy.');
             }
         });
+
+        describe('isDisabled', function () {
+            it('returns true if limit is disabled', function () {
+                const config = {
+                    disabled: true
+                };
+                const limit = new FlagLimit({name: 'flaggy', config, errors});
+
+                assert.equal(limit.isDisabled(), true);
+            });
+
+            it('returns false if limit is disabled', function () {
+                const config = {
+                    disabled: false
+                };
+                const limit = new FlagLimit({name: 'flaggy', config, errors});
+
+                assert.equal(limit.isDisabled(), false);
+            });
+
+            it('returns false if limit is not defined', function () {
+                const config = {
+                    disabled: undefined
+                };
+                const limit = new FlagLimit({name: 'flaggy', config, errors});
+
+                assert.equal(limit.isDisabled(), false);
+            });
+        });
     });
 
     describe('Max Limit', function () {