payment-kit 1.13.128 → 1.13.129

package/api/src/routes/connect/setup.ts

@@ -8,7 +8,7 @@ import { wallet } from '../../libs/auth';
 import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/payment';
 import { getFastCheckoutAmount } from '../../libs/session';
 import { OCAP_PAYMENT_TX_TYPE, getTxMetadata } from '../../libs/util';
-import { subscriptionQueue } from '../../queues/subscription';
+import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
 import { ensureSetupIntent, getAuthPrincipalClaim, getTokenRequirements } from './shared';
 
@@ -136,14 +136,7 @@ export default {
       });
 
       await checkoutSession.update({ status: 'complete', payment_status: 'paid' });
-
-      // FIXME: for trialing subscriptions should we do this after 1st normal cycle
-      subscriptionQueue.push({
-        id: subscription.id,
-        job: { subscriptionId: subscription.id, action: 'cycle' },
-        // our next invoice should be generated at the end of current period, either trailing or normal
-        runAt: subscription.trail_end || subscription.current_period_end,
-      });
+      await addSubscriptionJob(subscription, 'cycle', false, subscription.trail_end);
 
       return { hash: txHash };
     }

package/api/src/routes/connect/subscribe.ts

@@ -10,7 +10,7 @@ import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/paymen
 import { getFastCheckoutAmount } from '../../libs/session';
 import { OCAP_PAYMENT_TX_TYPE, getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
-import { subscriptionQueue } from '../../queues/subscription';
+import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
 import { ensureInvoiceForCheckout, ensurePaymentIntent, getAuthPrincipalClaim, getTokenRequirements } from './shared';
 
@@ -137,12 +137,7 @@ export default {
       if (invoice) {
         invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
       }
-      subscriptionQueue.push({
-        id: subscription.id,
-        job: { subscriptionId: subscription.id, action: 'cycle' },
-        // our next invoice should be generated at the end of current period, either trailing or normal
-        runAt: subscription.trail_end || subscription.current_period_end,
-      });
+      await addSubscriptionJob(subscription, 'cycle', false, subscription.trail_end);
 
       return { hash: txHash };
     }

package/api/src/routes/connect/update.ts

@@ -9,7 +9,7 @@ import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/paymen
 import { getFastCheckoutAmount } from '../../libs/session';
 import { OCAP_PAYMENT_TX_TYPE, getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
-import { subscriptionQueue } from '../../queues/subscription';
+import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
 import { ensureSubscription, getAuthPrincipalClaim, getTokenRequirements } from './shared';
 
@@ -118,12 +118,7 @@ export default {
         });
       }
       if (subscription) {
-        subscriptionQueue.push({
-          id: subscription.id,
-          job: { subscriptionId: subscription.id, action: 'cycle' },
-          // our next invoice should be generated at the end of current period, either trailing or normal
-          runAt: subscription.trail_end || subscription.current_period_end,
-        });
+        await addSubscriptionJob(subscription, 'cycle', false, subscription.trail_end);
       }
 
       return { hash: txHash };

package/api/src/routes/subscriptions.ts

@@ -12,15 +12,11 @@ import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import { isDelegationSufficientForPayment } from '../libs/payment';
 import { authenticate } from '../libs/security';
-import {
-  expandLineItems,
-  getPriceUintAmountByCurrency,
-  getSubscriptionCreateSetup,
-  isLineItemAligned,
-} from '../libs/session';
+import { expandLineItems, getPriceUintAmountByCurrency, isLineItemAligned } from '../libs/session';
+import { getSubscriptionCreateSetup } from '../libs/subscription';
 import { MAX_SUBSCRIPTION_ITEM_COUNT, formatMetadata } from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
-import { subscriptionQueue } from '../queues/subscription';
+import { addSubscriptionJob, subscriptionQueue } from '../queues/subscription';
 import type { TLineItemExpanded } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
@@ -230,22 +226,21 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     updates.cancel_at = doc.current_period_end;
     updates.cancelation_details = { reason: 'cancellation_requested', feedback, comment };
     updates.canceled_at = dayjs().unix();
+    await addSubscriptionJob(doc, 'cancel', true, updates.cancel_at);
   } else if (at === 'now') {
     updates.status = 'canceled';
     updates.cancel_at = dayjs().unix();
     updates.canceled_at = dayjs().unix();
+    await addSubscriptionJob(doc, 'cancel', true, updates.cancel_at);
   } else if (at === 'current_period_end') {
     updates.cancel_at_period_end = true;
     updates.cancel_at = doc.current_period_end;
     updates.canceled_at = dayjs().unix();
+    await addSubscriptionJob(doc, 'cancel', true, updates.cancel_at);
   } else {
     updates.cancel_at = dayjs(time).unix();
     updates.canceled_at = dayjs().unix();
-    subscriptionQueue.push({
-      id: `cancel-${doc.id}`,
-      job: { subscriptionId: doc.id, action: 'cancel' },
-      runAt: updates.cancel_at,
-    });
+    await addSubscriptionJob(doc, 'cancel', updates.cancel_at < doc.current_period_end, updates.cancel_at);
   }
 
   if (doc.payment_details?.stripe?.subscription_id) {
@@ -289,14 +284,10 @@ router.put('/:id/recover', authPortal, async (req, res) => {
 
   // reschedule jobs
   subscriptionQueue
-    .cancel(`cancel-${doc.id}`)
+    .delete(`cancel-${doc.id}`)
     .then(() => logger.info('subscription cancel job is canceled'))
     .catch((err) => logger.error('subscription cancel job failed to cancel', { error: err }));
-  subscriptionQueue.push({
-    id: doc.id,
-    job: { subscriptionId: doc.id, action: 'cycle' },
-    runAt: doc.current_period_end,
-  });
+  await addSubscriptionJob(doc, 'cycle');
 
   return res.json(doc);
 });
@@ -334,11 +325,7 @@ router.put('/:id/pause', auth, async (req, res) => {
   });
 
   if (timestamp) {
-    subscriptionQueue.push({
-      id: `resume-${doc.id}`,
-      job: { subscriptionId: doc.id, action: 'resume' },
-      runAt: timestamp,
-    });
+    await addSubscriptionJob(doc, 'resume', false, timestamp);
   }
 
   return res.json(doc);
@@ -358,7 +345,7 @@ router.put('/:id/resume', auth, async (req, res) => {
   await doc.update({ status: 'active', pause_collection: undefined });
 
   subscriptionQueue
-    .cancel(`resume-${doc.id}`)
+    .delete(`resume-${doc.id}`)
     .then(() => logger.info('subscription resume job is canceled'))
     .catch((err) => logger.error('subscription resume job failed to cancel', { error: err }));
 
@@ -852,12 +839,7 @@ router.put('/:id', authPortal, async (req, res) => {
 
         if (invoice.status === 'paid') {
           await subscriptionQueue.delete(subscription.id);
-          subscriptionQueue.push({
-            id: subscription.id,
-            job: { subscriptionId: subscription.id, action: 'cycle' },
-            // our next invoice should be generated at the end of current period, either trailing or normal
-            runAt: subscription.trail_end || subscription.current_period_end,
-          });
+          await addSubscriptionJob(subscription, 'cycle', false, subscription.trail_end);
         } else {
           await subscription.update({ status: 'past_due' });
           logger.info('subscription past_due on invoice paid', {

package/api/src/routes/usage-records.ts

@@ -7,6 +7,7 @@ import { Op } from 'sequelize';
 import { forwardUsageRecordToStripe } from '../integrations/stripe/resource';
 import dayjs from '../libs/dayjs';
 import { authenticate } from '../libs/security';
+import { usageRecordQueue } from '../queues/usage-record';
 import { Invoice, Price, Subscription, SubscriptionItem, UsageRecord } from '../store/models';
 
 const router = Router();
@@ -20,21 +21,35 @@ router.post('/', auth, async (req, res) => {
     return res.status(400).json({ error: `SubscriptionItem not found: ${raw.subscription_item_id}` });
   }
 
+  const subscription = await Subscription.findByPk(item.subscription_id);
+  if (!subscription) {
+    return res.status(400).json({ error: `Subscription not found: ${item.subscription_id}` });
+  }
+  if (raw.timestamp) {
+    if (raw.timestamp < subscription.current_period_start || raw.timestamp > subscription.current_period_end) {
+      return res.status(400).json({ error: '`timestamp` must be within the current period' });
+    }
+  }
+
   // @ts-ignore
   if (!raw.timestamp || raw.timestamp === 'now') {
     raw.timestamp = dayjs().unix();
   }
 
-  let doc = await UsageRecord.findOne({ where: { timestamp: raw.timestamp } });
+  let doc = await UsageRecord.findOne({
+    where: { timestamp: raw.timestamp, subscription_item_id: raw.subscription_item_id },
+  });
   if (doc) {
+    if (doc.billed) {
+      return res.status(400).json({ error: 'UsageRecord is immutable because already billed' });
+    }
     if (req.body.action === 'increment') {
       await doc.increment('quantity', { by: raw.quantity });
     } else {
-      const subscription = await Subscription.findByPk(item.subscription_id);
-      if (subscription?.billing_thresholds) {
+      if (subscription.billing_thresholds?.amount_gte) {
         return res
           .status(400)
-          .json({ error: 'UsageRecord action must be increment for subscriptions with billing_thresholds' });
+          .json({ error: 'UsageRecord action must be `increment` for subscriptions with billing_thresholds' });
       }
       await doc.update({ quantity: raw.quantity });
     }
@@ -43,6 +58,13 @@ router.post('/', auth, async (req, res) => {
     doc = await UsageRecord.create(raw as UsageRecord);
   }
 
+  if (subscription.billing_thresholds?.amount_gte) {
+    usageRecordQueue.push({
+      id: `usage-${subscription.id}`,
+      job: { subscriptionId: subscription.id, subscriptionItemId: item.id },
+    });
+  }
+
   await forwardUsageRecordToStripe(item, {
     quantity: Number(raw.quantity),
     timestamp: raw.timestamp,
@@ -75,16 +97,6 @@ router.get('/summary', auth, async (req, res) => {
       return res.status(400).json({ error: `SubscriptionItem not found: ${query.subscription_item_id}` });
     }
 
-    // const subscription = await Subscription.findByPk(item.subscription_id);
-    // const result = await UsageRecord.getSummary(
-    //   item.id,
-    //   subscription?.current_period_start as number,
-    //   subscription?.current_period_end as number,
-    //   // @ts-ignore
-    //   item.price.recurring.aggregate_usage
-    // );
-    // return res.json({ result });
-
     const { rows, count } = await Invoice.findAndCountAll({
       where: { subscription_id: item.subscription_id },
       attributes: ['id', 'period_end', 'period_start'],
@@ -99,13 +111,14 @@ router.get('/summary', auth, async (req, res) => {
           livemode: invoice.livemode,
           invoice_id: invoice.id,
           subscription_item_id: item.id,
-          total_usage: await UsageRecord.getSummary(
-            item.id,
-            invoice.period_start,
-            invoice.period_end,
+          total_usage: await UsageRecord.getSummary({
+            id: item.id,
+            start: invoice.period_start,
+            end: invoice.period_end,
             // @ts-ignore
-            item.price.recurring.aggregate_usage
-          ),
+            method: item.price.recurring.aggregate_usage,
+            dryRun: true,
+          }),
           period: {
             start: invoice.period_start,
             end: invoice.period_end,

package/api/src/store/migrations/20240202-usage-billed.ts

@@ -0,0 +1,22 @@
+/* eslint-disable no-await-in-loop */
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    usage_records: [
+      {
+        name: 'billed',
+        field: {
+          type: DataTypes.BOOLEAN,
+          defaultValue: false,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('usage_records', 'billed');
+};

package/api/src/store/models/checkout-session.ts

@@ -159,6 +159,7 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
     description: string;
     trial_period_days: number;
     billing_cycle_anchor?: number;
+    billing_threshold_amount?: number;
     metadata?: Record<string, any>;
     proration_behavior?: LiteralUnion<'create_prorations' | 'none', string>;
     trial_end?: number;

package/api/src/store/models/price.ts

@@ -230,6 +230,16 @@ export class Price extends Model<InferAttributes<Price>, InferCreationAttributes
     return 'standard';
   }
 
+  public transformQuantity(quantity: number) {
+    if (this.transform_quantity) {
+      if (this.transform_quantity.round === 'up') {
+        return Math.ceil(quantity / this.transform_quantity.divide_by);
+      }
+      return Math.floor(quantity / this.transform_quantity.divide_by);
+    }
+    return quantity;
+  }
+
   public static formatBeforeSave(price: Partial<TPrice & { model: string }>) {
     if (price.type) {
       if (price.type === 'recurring') {

package/api/src/store/models/usage-record.ts

@@ -10,6 +10,7 @@ export class UsageRecord extends Model<InferAttributes<UsageRecord>, InferCreati
   declare id: CreationOptional<string>;
 
   declare livemode: boolean;
+  declare billed: boolean;
 
   // The timestamp when this usage occurred.
   declare timestamp: number;
@@ -68,13 +69,22 @@ export class UsageRecord extends Model<InferAttributes<UsageRecord>, InferCreati
   };
 
   public static initialize(sequelize: any) {
-    this.init(UsageRecord.GENESIS_ATTRIBUTES, {
-      sequelize,
-      modelName: 'UsageRecord',
-      tableName: 'usage_records',
-      createdAt: 'created_at',
-      updatedAt: 'updated_at',
-    });
+    this.init(
+      {
+        ...UsageRecord.GENESIS_ATTRIBUTES,
+        billed: {
+          type: DataTypes.BOOLEAN,
+          defaultValue: false,
+        },
+      },
+      {
+        sequelize,
+        modelName: 'UsageRecord',
+        tableName: 'usage_records',
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+      }
+    );
   }
 
   public static associate(models: any) {
@@ -84,44 +94,58 @@ export class UsageRecord extends Model<InferAttributes<UsageRecord>, InferCreati
     });
   }
 
-  public static async getSummary(
-    subscription_item_id: string,
-    period_start: number,
-    period_end: number,
-    method: LiteralUnion<'sum' | 'last_during_period' | 'max' | 'last_ever', string>
-  ): Promise<number> {
+  public static async getSummary({
+    id,
+    start,
+    end,
+    method,
+    dryRun,
+  }: {
+    id: string;
+    start: number;
+    end: number;
+    method: LiteralUnion<'sum' | 'last_during_period' | 'max' | 'last_ever', string>;
+    dryRun: boolean;
+  }): Promise<number> {
     const query = {
       where: {
-        subscription_item_id,
+        subscription_item_id: id,
+        billed: false,
         timestamp: {
-          [Op.gte]: period_start,
-          [Op.lt]: period_end,
+          [Op.gte]: start,
+          [Op.lt]: end,
         },
       },
       order: [['timestamp', 'DESC']],
     };
 
+    const update = () => (dryRun ? Promise.resolve() : UsageRecord.update({ billed: true }, query));
+
     if (method === 'sum') {
       const sum = await this.sum('quantity', query);
+      await update();
       return sum || 0;
     }
 
     if (method === 'max') {
       const max = await this.max('quantity', query);
+      await update();
       return (max as number) || 0;
     }
 
     if (method === 'last_during_period') {
       // @ts-ignore
       const item = await this.findOne(query);
+      await update();
       return item ? item.quantity : 0;
     }
 
     if (method === 'last_ever') {
       const item = await this.findOne({
-        where: { subscription_item_id },
+        where: { subscription_item_id: id },
         order: [['timestamp', 'DESC']],
       });
+      await update();
       return item ? item.quantity : 0;
     }
 

package/api/tests/libs/session.spec.ts

@@ -1,10 +1,8 @@
-import dayjs from '../../src/libs/dayjs';
 import {
   getCheckoutMode,
   getPriceCurrencyOptions,
   getPriceUintAmountByCurrency,
   getRecurringPeriod,
-  getSubscriptionCreateSetup,
 } from '../../src/libs/session';
 import type { TLineItemExpanded } from '../../src/store/models';
 
@@ -137,78 +135,3 @@ describe('getRecurringPeriod', () => {
     expect(result).toBe(0);
   });
 });
-
-describe('getSubscriptionCreateSetup', () => {
-  const currencies = [
-    {
-      currency_id: 'usd',
-      unit_amount: '1',
-    },
-  ];
-
-  it('should calculate setup for recurring licensed price type', () => {
-    const items = [
-      {
-        price: { type: 'one_time', currency_options: currencies },
-        quantity: 1,
-      },
-      {
-        price: {
-          type: 'recurring',
-          currency_options: currencies,
-          recurring: { interval: 'day', interval_count: '1', usage_type: 'licensed' },
-        },
-        quantity: 2,
-      },
-    ];
-    const result = getSubscriptionCreateSetup(items as any, 'usd');
-    expect(result.amount.setup).toBe('3');
-  });
-
-  it('should not calculate setup for recurring metered price type', () => {
-    const items = [
-      {
-        price: { type: 'one_time', currency_options: currencies },
-        quantity: 1,
-      },
-      {
-        price: {
-          type: 'recurring',
-          currency_options: currencies,
-          recurring: { interval: 'day', interval_count: '1', usage_type: 'metered' },
-        },
-        quantity: 2,
-      },
-    ];
-    const result = getSubscriptionCreateSetup(items as any, 'usd');
-    expect(result.amount.setup).toBe('1');
-  });
-
-  it('should calculate cycle duration for recurring price type', () => {
-    const items = [
-      {
-        price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
-        quantity: 2,
-      },
-    ];
-    const result = getSubscriptionCreateSetup(items as any, 'usd');
-    expect(result.cycle.duration).toBe(24 * 60 * 60 * 1000);
-  });
-
-  it('should calculate trial period when trialInDays is provided', () => {
-    const items = [
-      {
-        price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
-        quantity: 2,
-      },
-    ];
-    const result = getSubscriptionCreateSetup(items as any, 'usd', 7);
-    const now = dayjs().unix();
-    expect(result.trail.start).toBe(now);
-    expect(result.trail.end).toBe(
-      dayjs()
-        .add(7 * 24 * 60 * 60 * 1000, 'millisecond')
-        .unix()
-    );
-  });
-});

package/api/tests/libs/subscription.spec.ts

@@ -1,4 +1,11 @@
-import { getDaysUntilDue, getDueUnit, getMaxRetryCount, getMinRetryMail } from '../../src/libs/subscription';
+import dayjs from '../../src/libs/dayjs';
+import {
+  getDaysUntilDue,
+  getDueUnit,
+  getMaxRetryCount,
+  getMinRetryMail,
+  getSubscriptionCreateSetup,
+} from '../../src/libs/subscription';
 
 describe('getDueUnit', () => {
   it('should return 60 for recurring interval of "hour"', () => {
@@ -87,3 +94,78 @@ describe('getMinRetryMail', () => {
     expect(result).toBe(15);
   });
 });
+
+describe('getSubscriptionCreateSetup', () => {
+  const currencies = [
+    {
+      currency_id: 'usd',
+      unit_amount: '1',
+    },
+  ];
+
+  it('should calculate setup for recurring licensed price type', () => {
+    const items = [
+      {
+        price: { type: 'one_time', currency_options: currencies },
+        quantity: 1,
+      },
+      {
+        price: {
+          type: 'recurring',
+          currency_options: currencies,
+          recurring: { interval: 'day', interval_count: '1', usage_type: 'licensed' },
+        },
+        quantity: 2,
+      },
+    ];
+    const result = getSubscriptionCreateSetup(items as any, 'usd');
+    expect(result.amount.setup).toBe('3');
+  });
+
+  it('should not calculate setup for recurring metered price type', () => {
+    const items = [
+      {
+        price: { type: 'one_time', currency_options: currencies },
+        quantity: 1,
+      },
+      {
+        price: {
+          type: 'recurring',
+          currency_options: currencies,
+          recurring: { interval: 'day', interval_count: '1', usage_type: 'metered' },
+        },
+        quantity: 2,
+      },
+    ];
+    const result = getSubscriptionCreateSetup(items as any, 'usd');
+    expect(result.amount.setup).toBe('1');
+  });
+
+  it('should calculate cycle duration for recurring price type', () => {
+    const items = [
+      {
+        price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
+        quantity: 2,
+      },
+    ];
+    const result = getSubscriptionCreateSetup(items as any, 'usd');
+    expect(result.cycle.duration).toBe(24 * 60 * 60 * 1000);
+  });
+
+  it('should calculate trial period when trialInDays is provided', () => {
+    const items = [
+      {
+        price: { type: 'recurring', currency_options: currencies, recurring: { interval: 'day', interval_count: '1' } },
+        quantity: 2,
+      },
+    ];
+    const result = getSubscriptionCreateSetup(items as any, 'usd', 7);
+    const now = dayjs().unix();
+    expect(result.trail.start).toBe(now);
+    expect(result.trail.end).toBe(
+      dayjs()
+        .add(7 * 24 * 60 * 60 * 1000, 'millisecond')
+        .unix()
+    );
+  });
+});

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.13.128
+version: 1.13.129
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.13.128",
+  "version": "1.13.129",
   "scripts": {
     "dev": "cross-env COMPONENT_STORE_URL=https://test.store.blocklet.dev blocklet dev",
     "eject": "vite eject",
@@ -50,7 +50,7 @@
     "@arcblock/jwt": "^1.18.108",
     "@arcblock/ux": "^2.9.23",
     "@blocklet/logger": "1.16.23-beta-aeb9f5bd",
-    "@blocklet/payment-react": "1.13.128",
+    "@blocklet/payment-react": "1.13.129",
     "@blocklet/sdk": "1.16.23-beta-aeb9f5bd",
     "@blocklet/ui-react": "^2.9.23",
     "@blocklet/uploader": "^0.0.69",
@@ -110,7 +110,7 @@
   "devDependencies": {
     "@abtnode/types": "1.16.23-beta-aeb9f5bd",
     "@arcblock/eslint-config-ts": "^0.2.4",
-    "@blocklet/payment-types": "1.13.128",
+    "@blocklet/payment-types": "1.13.129",
     "@types/cookie-parser": "^1.4.6",
     "@types/cors": "^2.8.17",
     "@types/dotenv-flow": "^3.3.3",
@@ -149,5 +149,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "b518cfcb827855501a03f0675cb9025e75b8538e"
+  "gitHead": "4ad81bea01de3268d9cf0bda552a0a0a67abd85d"
 }

package/src/libs/util.ts

@@ -185,7 +185,10 @@ export function isPriceRecurringAligned(list: LineItem[], products: TProductExpa
     }
 
     // If the interval and interval_count are different, the recurring is not aligned
-    if (recurring?.interval !== x.recurring?.interval || recurring?.interval_count !== x.recurring?.interval_count) {
+    if (
+      String(recurring?.interval) !== String(x.recurring?.interval) ||
+      Number(recurring?.interval_count) !== Number(x.recurring?.interval_count)
+    ) {
       return false;
     }