@tryghost/limit-service 1.3.1 → 1.4.0

package/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!');
@@ -158,7 +172,7 @@ db.transaction((transacting) => {
 
 ### Types of limits
 At the moment there are four different types of limits that limit service allows to define. These types are:
-1. `flag` - is an "on/off" switch for certain feature. Example use case: "disable all emails". It's identified by a `disabled: true` property in the "limits" configuration. It is possible to overwrite the limit by providing a `currentCountQuery` for it. This is useful in cases where we introduce new limits to existing plans and customers have already been using the feature affected by the limit. By providing a `currentCountQuery` that detects if the feature is already in use, we won't disable it.
+1. `flag` - is an "on/off" switch for certain feature. Example use case: "disable all emails". It's identified by a `disabled: true` property in the "limits" configuration.
 2. `max` - checks if the maximum amount of the resource has been used up.Example use case: "disable creating a staff user when maximum of 5 has been reached". To configure this limit add `max: NUMBER` to the configuration. The limits that support max checks are: `members`, and `staff`
 3. `maxPeriodic` - it's a variation of `max` type with a difference that the check is done over certain period of time. Example use case: "disable sending emails when the sent emails count has acceded a limit for last billing period". To enable this limit define `maxPeriodic: NUMBER` in the limit configuration and provide a subscription configuration when initializing the limit service instance. The subscription object comes as a separate parameter and has to contain two properties: `startDate` and `interval`, where `startDate` is a date in  ISO 8601 format and period is `'month'` (other values like `'year'` are not supported yet)
 4. `allowList` - checks if provided value is defined in configured "allowlist". Example use case: "disable theme activation if it is not an official theme". To configure this limit define ` allowlist: ['VALUE_1', 'VALUE_2', 'VALUE_N']` property in the "limits" parameter.

package/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

package/lib/limit.js

@@ -264,7 +264,6 @@ class FlagLimit extends Limit {
      * @param {Number} options.config.disabled - disabled/enabled flag for the limit
      * @param {String} options.config.error - error message to use when limit is reached
      * @param {String} options.helpLink - URL to the resource explaining how the limit works
-     * @param {Function} [options.config.currentCountQuery] - query checking the state that would be compared against the limit
      * @param {Object} [options.db] - instance of knex db connection that currentCountQuery can use to run state check through
      * @param {Object} options.errors - instance of errors compatible with GhostError errors (@tryghost/errors)
      */
@@ -274,7 +273,6 @@ class FlagLimit extends Limit {
 
         this.disabled = config.disabled;
         this.fallbackMessage = `Your plan does not support ${userFacingLimitName}. Please upgrade to enable ${userFacingLimitName}.`;
-        this.currentCountQueryFn = config?.currentCountQuery || null;
     }
 
     generateError() {
@@ -290,59 +288,28 @@ class FlagLimit extends Limit {
     }
 
     /**
-     * @param {Object} [options]
-     * @param {Object} [options.transacting] Transaction to run the count query on
-     * @returns {Promise<boolean>} - returns the current count of items that would be compared against the limit
+     * Flag limits are on/off so using a feature is always over the limit
      */
-    async currentCountQuery(options = {}) {
-        if (!this.currentCountQueryFn || typeof this.currentCountQueryFn !== 'function') {
-            return false;
-        }
-
-        return await this.currentCountQueryFn(options.transacting ?? this.db?.knex);
-    }
-
-    // As Flag limits are on/off, we won't check against max values.
-    // `errorIfWouldGoOverLimit` and `errorIfIsOverLimit` end up doing the same thing.
-    async _isOrWouldOverLimitError(options = {}) {
-        if (!this.disabled) {
-            return;
-        }
-
-        // If no currentCountQuery is provided, throw error when disabled
-        if (!this.currentCountQueryFn || typeof this.currentCountQueryFn !== 'function') {
-            throw this.generateError();
-        }
-
-        // If currentCountQuery is provided, check if feature is in use
-        const featureInUse = await this.currentCountQuery(options);
-
-        // Only throw error if feature is NOT in use (allowing grandfathering)
-        if (!featureInUse) {
+    async errorIfWouldGoOverLimit() {
+        if (this.disabled) {
             throw this.generateError();
         }
     }
 
     /**
-     * Flag limits are usually on/off so using a feature is always over the limit,
-     * unless the limit has a currentCountQuery function provided to check if the
-     * feature is in use. This is a use case for when we introduce a new limit and
-     * customers have already been using this feature. We don't want to take it
-     * away from them.
+     * Flag limits are on/off. They don't necessarily mean the limit wasn't possible to reach
+     * NOTE: this method should not be relied on as it's impossible to check the limit was surpassed!
      */
-    async errorIfWouldGoOverLimit(options = {}) {
-        await this._isOrWouldOverLimitError(options);
+    async errorIfIsOverLimit() {
+        return;
     }
 
     /**
-     * Flag limits are on/off. They don't necessarily mean the limit wasn't possible to reach
-     * Exception: the limit has a currentCountQuery function provided to check if the
-     * feature is in use. This is a use case for when we introduce a new limit and
-     * customers have already been using this feature. We don't want to take it
-     * away from them.
+     * Checks whether the Flag limit is disabled or not
+     * @returns boolean
      */
-    async errorIfIsOverLimit(options = {}) {
-        await this._isOrWouldOverLimitError(options);
+    isDisabled() {
+        return !!this.disabled;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/limit-service",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TryGhost/SDK.git",
@@ -34,5 +34,5 @@
     "lodash": "^4.17.21",
     "luxon": "^1.26.0"
   },
-  "gitHead": "01a3b9421038ee84b0e0198a7d83740673eade12"
+  "gitHead": "8d4cf3dfddc7c9fd6c499e672be94e64123b23bd"
 }