payment-kit 1.13.92 → 1.13.94

package/api/src/routes/subscriptions.ts

@@ -10,6 +10,7 @@ import { Transaction, WhereOptions } from 'sequelize';
 import { getWhereFromQuery } from '../libs/api';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
+import { isDelegationSufficientForPayment } from '../libs/payment';
 import { authenticate } from '../libs/security';
 import {
   expandLineItems,
@@ -17,9 +18,10 @@ import {
   getSubscriptionCreateSetup,
   isLineItemAligned,
 } from '../libs/session';
-import { MAX_SUBSCRIPTION_ITEM_COUNT, formatMetadata } from '../libs/util';
+import { MAX_SUBSCRIPTION_ITEM_COUNT, formatMetadata, sleep } from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
 import { subscriptionQueue } from '../queues/subscription';
+import type { TLineItemExpanded } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -27,9 +29,11 @@ import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentIntent } from '../store/models/payment-intent';
 import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
+import { PricingTable } from '../store/models/pricing-table';
 import { Product } from '../store/models/product';
 import { Subscription, TSubscription } from '../store/models/subscription';
-import { SubscriptionItem, TSubscriptionItem } from '../store/models/subscription-item';
+import { SubscriptionItem } from '../store/models/subscription-item';
+import type { LineItem, SubscriptionUpdateItem } from '../store/models/types';
 import { UsageRecord } from '../store/models/usage-record';
 import { sequelize } from '../store/sequelize';
 import { ensureInvoiceAndItems } from './connect/shared';
@@ -277,8 +281,10 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not recoverable from cancellation' });
   }
 
-  await updateStripeSubscription(doc, { cancel_at_period_end: false });
-  await doc.update({ cancel_at_period_end: false });
+  await updateStripeSubscription(doc, { cancel_at_period_end: false, cancel_at: null, canceled_at: null });
+
+  // @ts-ignore
+  await doc.update({ cancel_at_period_end: false, cancel_at: null, canceled_at: null });
 
   // reschedule jobs
   subscriptionQueue
@@ -358,7 +364,7 @@ router.put('/:id/resume', auth, async (req, res) => {
   return res.json(doc);
 });
 
-const isValidSubscriptionItemChange = (item: TSubscriptionItem & { [key: string]: any }) => {
+const isValidSubscriptionItemChange = (item: SubscriptionUpdateItem) => {
   if (item.deleted) {
     if (!item.id) {
       throw new Error('You must delete subscription item with id');
@@ -382,20 +388,208 @@ const isValidSubscriptionItemChange = (item: TSubscriptionItem & { [key: string]
   return true;
 };
 
-// TODO: forward changes to stripe
+const validateSubscriptionUpdateRequest = async (subscription: Subscription, items: SubscriptionUpdateItem[]) => {
+  // validate
+  items.every(isValidSubscriptionItemChange);
+
+  // ensure no duplicate id
+  const ids = items.filter((x: any) => x.id).map((x: any) => x.id);
+  if (uniq(ids).length !== ids.length) {
+    throw new Error('Subscription item should not have duplicate id');
+  }
+
+  // ensure no duplicate price_id
+  const priceIds = items.filter((x: any) => x.price_id).map((x: any) => x.price_id);
+  if (uniq(priceIds).length !== priceIds.length) {
+    throw new Error('Subscription item should not have duplicate price_id');
+  }
+
+  const addedItems = await Price.expand(items.filter((x: any) => x.price_id && !x.id) as LineItem[]);
+  if (addedItems.some((x) => !x.price)) {
+    throw new Error('Subscription item should not use non-exist price');
+  }
+  if (addedItems.some((x) => !x.price.active)) {
+    throw new Error('Subscription item should not use archived price');
+  }
+  for (let i = 0; i < addedItems.length; i++) {
+    const result = isLineItemAligned(addedItems, i);
+    if (result.currency === false) {
+      throw new Error('New subscription items should have same currency');
+    }
+    if (result.recurring === false) {
+      throw new Error('New subscription items should have same recurring');
+    }
+  }
+
+  const existingItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+  const deletedItems = items.filter((x: any) => x.deleted && x.id).map((x: any) => x.id);
+  if (existingItems.length - deletedItems.length + addedItems.length === 0) {
+    throw new Error('Subscription should have at least one subscription item');
+  }
+
+  const existingExpanded = await Price.expand(
+    existingItems.filter((x) => deletedItems.includes(x.id) === false).map((x) => x.toJSON())
+  );
+
+  // try handle cross-sell with different interval, just replace with new price that have same interval
+  const newRecurring = addedItems.find((x) => x.price.type === 'recurring')?.price.recurring;
+  await Promise.all(
+    existingExpanded.map(async (x: TLineItemExpanded) => {
+      const oldRecurring = x.price.recurring;
+      if (
+        newRecurring?.interval !== oldRecurring?.interval ||
+        newRecurring?.interval_count !== oldRecurring?.interval_count
+      ) {
+        const prices = await Price.findAll({
+          where: { product_id: x.price.product_id, type: 'recurring', active: true },
+          include: [{ model: Product, as: 'product' }],
+        });
+
+        const newPrice = prices.find(
+          (y) =>
+            y.recurring?.interval === newRecurring?.interval &&
+            y.recurring?.interval_count === newRecurring?.interval_count
+        );
+
+        if (newPrice) {
+          logger.info('Replace subscription item on update', {
+            subscription: subscription.id,
+            item: x.id,
+            oldPrice: x.price.id,
+            newPrice: newPrice.id,
+          });
+          x.price_id = newPrice.id;
+          x.price = newPrice.toJSON();
+          return x;
+        }
+
+        throw new Error(`Replacement price missing for ${x.id} when interval changed`);
+      }
+
+      return x;
+    })
+  );
+
+  // FIXME: following logic should be extracted
+  const newItems: any[] = [...existingExpanded, ...addedItems];
+  if (newItems.length > MAX_SUBSCRIPTION_ITEM_COUNT) {
+    throw new Error(`Subscription should not have more than ${MAX_SUBSCRIPTION_ITEM_COUNT} items`);
+  }
+  for (let i = 0; i < newItems.length; i++) {
+    const result = isLineItemAligned(newItems, i);
+    if (result.currency === false) {
+      throw new Error('Subscription item should have same currency');
+    }
+    if (result.recurring === false) {
+      throw new Error('Subscription item should have same recurring');
+    }
+  }
+
+  return {
+    existingItems,
+    addedItems,
+    newItems,
+  };
+};
+
+const createProration = async (subscription: TSubscription, setup: ReturnType<typeof getSubscriptionCreateSetup>) => {
+  const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
+  if (!lastInvoice) {
+    throw new Error('Subscription should have latest invoice when create proration');
+  }
+
+  // 1. get last invoice, and invoice items, filter invoice items that are in licensed recurring mode
+  const invoiceItems = await InvoiceItem.findAll({ where: { invoice_id: lastInvoice.id, proration: false } });
+  const invoiceItemsExpanded = await Price.expand(invoiceItems.map((x) => x.toJSON()));
+  const prorationItems = invoiceItemsExpanded.filter(
+    (x) => x.price.type === 'recurring' && x.price.recurring?.usage_type === 'licensed'
+  );
+
+  // 2. calculate proration args based on the filtered invoice items
+  const now = dayjs().unix();
+  const prorationStart = lastInvoice.period_start;
+  const prorationEnd = lastInvoice.period_end;
+  const prorationRate = Math.ceil(((prorationEnd - now) / (prorationEnd - prorationStart)) * 1000000);
+  let totalProrationAmount = new BN(0);
+  const prorations = await Promise.all(
+    prorationItems.map((x: TLineItemExpanded & { [key: string]: any }) => {
+      const unitAmount = getPriceUintAmountByCurrency(x.price, subscription.currency_id);
+      const prorationAmount = new BN(unitAmount)
+        .mul(new BN(x.quantity))
+        .mul(new BN(prorationRate))
+        .div(new BN(1000000))
+        .toString();
+      logger.info('subscription proration item', {
+        subscription: subscription.id,
+        invoice: x.invoice_id,
+        invoiceItem: x.id,
+        prorationAmount,
+      });
+      totalProrationAmount = totalProrationAmount.add(new BN(prorationAmount));
+
+      return {
+        price_id: x.price_id,
+        amount: `-${prorationAmount}`,
+        quantity: x.quantity,
+        // @ts-ignore
+        description: `Unused time on ${x.price.product.name} after ${dayjs().format('lll')}`,
+        period: {
+          start: lastInvoice.period_start,
+          end: lastInvoice.period_end,
+        },
+        proration: true,
+        proration_details: {
+          credited_items: {
+            invoice_id: lastInvoice.id,
+            // @ts-ignore
+            invoice_line_items: [x.id],
+          },
+        },
+      };
+    })
+  );
+  logger.info('subscription prorations created', {
+    subscription: subscription.id,
+    prorations,
+  });
+
+  // 5. adjust invoice total && update customer token balance
+  let total = new BN(setup.amount.setup);
+  let credit = new BN(setup.amount.setup);
+  if (total.gte(totalProrationAmount)) {
+    total = total.sub(totalProrationAmount).toString();
+    credit = '0';
+  } else {
+    credit = totalProrationAmount.sub(total).toString();
+    total = '0';
+  }
+
+  logger.info('subscription proration result', {
+    subscription: subscription.id,
+    prorationStart,
+    prorationEnd,
+    prorationRate,
+    totalProrationAmount,
+    total,
+    credit,
+  });
+
+  return {
+    lastInvoice,
+    total,
+    credit,
+    prorations,
+  };
+};
+
+// TODO: @wangshijun forward changes to stripe
 const updateSchema = Joi.object<{
   description?: string;
   metadata?: Record<string, any>;
   payment_behavior?: string;
   proration_behavior?: string;
   billing_cycle_anchor?: string;
-  items: {
-    id?: string;
-    deleted?: boolean;
-    clear_usage?: boolean;
-    price_id?: string;
-    quantity?: number;
-  }[];
+  items: SubscriptionUpdateItem[];
 }>({
   description: Joi.string().min(1).optional(),
   metadata: Joi.any().optional(),
@@ -416,7 +610,7 @@ const updateSchema = Joi.object<{
     .default([]),
 });
 // eslint-disable-next-line consistent-return
-router.put('/:id', auth, async (req, res) => {
+router.put('/:id', authPortal, async (req, res) => {
   logger.debug('subscription update request', { subscription: req.params.id, body: req.body });
   try {
     const { error } = updateSchema.validate(req.body);
@@ -458,6 +652,14 @@ router.put('/:id', auth, async (req, res) => {
       updates.proration_behavior = req.body.proration_behavior;
     }
 
+    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (!paymentMethod) {
+      throw new Error('Subscription should have payment method');
+    }
+    if (paymentMethod.type === 'stripe') {
+      throw new Error('Update is not supported for subscriptions paid with stripe');
+    }
+
     const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
     if (!paymentCurrency) {
       throw new Error('Subscription should have payment currency');
@@ -468,56 +670,23 @@ router.put('/:id', auth, async (req, res) => {
     }
 
     let invoice: Invoice;
+    let connectAction = '';
 
     await sequelize.transaction({ isolationLevel: Transaction.ISOLATION_LEVELS.READ_UNCOMMITTED }, async () => {
+      if (subscription.isActive() === false) {
+        return res.status(400).json({ error: 'Subscription is not active' });
+      }
+      if (subscription.isScheduledToCancel()) {
+        throw new Error('Subscription is scheduled to cancel');
+      }
+
       // handle subscription item changes
       if (Array.isArray(req.body.items) && req.body.items.length > 0) {
-        // validate
-        req.body.items.every(isValidSubscriptionItemChange);
-
-        // ensure no duplicate id
-        const ids = req.body.items.filter((x: any) => x.id).map((x: any) => x.id);
-        if (uniq(ids).length !== ids.length) {
-          throw new Error('Subscription item should not have duplicate id');
-        }
-
-        // ensure no duplicate price_id
-        const priceIds = req.body.items.filter((x: any) => x.price_id).map((x: any) => x.price_id);
-        if (uniq(priceIds).length !== priceIds.length) {
-          throw new Error('Subscription item should not have duplicate price_id');
-        }
-
-        const addedItems = await Price.expand(req.body.items.filter((x: any) => x.price_id && !x.id));
-        if (addedItems.some((x) => !x.price)) {
-          throw new Error('Subscription item should not use non-exist price');
-        }
-        if (addedItems.some((x) => !x.price.active)) {
-          throw new Error('Subscription item should not use archived price');
-        }
-
-        const existingItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
-        const deletedItems = req.body.items.filter((x: any) => x.deleted && x.id).map((x: any) => x.id);
-        if (existingItems.length - deletedItems.length + addedItems.length === 0) {
-          throw new Error('Subscription should have at least one subscription item');
-        }
-
-        // FIXME: following logic should be extracted
-        const existingExpanded = await Price.expand(
-          existingItems.filter((x) => deletedItems.includes(x.id) === false).map((x) => x.toJSON())
+        // validate the request
+        const { existingItems, addedItems, newItems } = await validateSubscriptionUpdateRequest(
+          subscription,
+          req.body.items
         );
-        const newItems: any[] = [...existingExpanded, ...addedItems];
-        if (newItems.length > MAX_SUBSCRIPTION_ITEM_COUNT) {
-          throw new Error(`Subscription should not have more than ${MAX_SUBSCRIPTION_ITEM_COUNT} items`);
-        }
-        for (let i = 0; i < newItems.length; i++) {
-          const result = isLineItemAligned(newItems, i);
-          if (result.currency === false) {
-            throw new Error('Subscription item should have same currency');
-          }
-          if (result.recurring === false) {
-            throw new Error('Subscription item should have same recurring');
-          }
-        }
 
         // update subscription items
         for (const item of req.body.items) {
@@ -558,24 +727,8 @@ router.put('/:id', auth, async (req, res) => {
         // handle proration
         const prorationBehavior = updates.proration_behavior || subscription.proration_behavior || 'none';
         if (prorationBehavior === 'create_prorations') {
-          const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
-          if (!lastInvoice) {
-            throw new Error('Subscription should have latest invoice');
-          }
-
-          // 0. get last invoice, and invoice items, filter invoice items that are in licensed recurring mode
-          const invoiceItems = await InvoiceItem.findAll({ where: { invoice_id: lastInvoice.id } });
-          const invoiceItemsExpanded = await Price.expand(invoiceItems.map((x) => x.toJSON()));
-          const prorationItems = invoiceItemsExpanded.filter(
-            (x) => x.price.type === 'recurring' && x.price.recurring?.usage_type === 'licensed'
-          );
-
-          // 1. calculate proration amount based on the filtered invoice items
-          const now = dayjs().unix();
-          const prorationStart = lastInvoice.period_start;
-          const prorationEnd = lastInvoice.period_end;
-          const prorationRate = Math.ceil(((prorationEnd - now) / (prorationEnd - prorationStart)) * 1000000);
-          let totalProrationAmount = new BN(0);
+          // 1. create proration
+          const { lastInvoice, total, credit, prorations } = await createProration(subscription, setup);
 
           // 2. create new invoice: amount according to new subscription items
           // 3. create new invoice items: amount according to new subscription items
@@ -607,76 +760,42 @@ router.put('/:id', auth, async (req, res) => {
 
           // 4. create proration invoice items: amount according to proration amount
           const prorationInvoiceItems = await Promise.all(
-            prorationItems.map((x) => {
-              const unitAmount = getPriceUintAmountByCurrency(x.price, subscription.currency_id);
-              const prorationAmount = new BN(unitAmount)
-                .mul(new BN(x.quantity))
-                .mul(new BN(prorationRate))
-                .div(new BN(1000000))
-                .toString();
-              logger.info('subscription proration invoice item', { subscription: req.params.id, prorationAmount });
-              totalProrationAmount = totalProrationAmount.add(new BN(prorationAmount));
-
-              return InvoiceItem.create({
+            prorations.map((x: any) =>
+              InvoiceItem.create({
+                ...x,
                 livemode: subscription.livemode,
-                amount: `-${prorationAmount}`,
-                quantity: x.quantity,
-                // @ts-ignore
-                description: `Unused time on ${x.price.product.name} after ${dayjs().format('lll')}`,
-                period: {
-                  start: lastInvoice.period_start,
-                  end: lastInvoice.period_end,
-                },
                 currency_id: subscription.currency_id,
                 customer_id: customer.id,
                 price_id: x.price_id,
                 invoice_id: invoice.id,
                 subscription_id: subscription.id,
-                // @ts-ignore
                 subscription_item_id: x.subscription_item_id,
                 discountable: false,
                 discounts: [],
                 discount_amounts: [],
-                proration: true,
-                proration_details: {
-                  credited_items: {
-                    invoice_id: lastInvoice.id,
-                    // @ts-ignore
-                    invoice_line_items: [x.id],
-                  },
-                },
                 metadata: {},
-              });
-            })
+              })
+            )
           );
           logger.info('subscription proration invoice items created', {
             subscription: req.params.id,
             items: prorationInvoiceItems.map((x) => x.id),
           });
 
-          // 5. adjust invoice total && update customer token balance
-          const invoiceTotal = new BN(setup.amount.setup);
-          if (invoiceTotal.gt(totalProrationAmount)) {
-            const invoiceAmount = invoiceTotal.sub(totalProrationAmount).toString();
+          // 5. adjust invoice total or update customer credit balance
+          if (total !== '0') {
             await invoice.update({
               status: 'open',
-              subtotal: invoiceAmount,
-              subtotal_excluding_tax: invoiceAmount,
-              total: invoiceAmount,
-              amount_due: invoiceAmount,
-              amount_remaining: invoiceAmount,
-            });
-            logger.info('subscription proration used on invoice', {
-              subscription: req.params.id,
-              prorationStart,
-              prorationEnd,
-              prorationRate,
-              totalProrationAmount,
-              invoiceAmount,
+              subtotal: total,
+              subtotal_excluding_tax: total,
+              total,
+              amount_due: total,
+              amount_remaining: total,
             });
-          } else {
-            const customerCredit = totalProrationAmount.sub(invoiceTotal).toString();
-            const balance = await customer.increaseTokenBalance(paymentCurrency.id, customerCredit);
+            logger.info('subscription proration used on invoice', { subscription: req.params.id, total });
+          }
+          if (credit !== '0') {
+            const balance = await customer.increaseTokenBalance(paymentCurrency.id, credit);
             await invoice.update({
               status: 'open',
               subtotal: '0',
@@ -687,35 +806,64 @@ router.put('/:id', auth, async (req, res) => {
               starting_token_balance: balance.starting,
               ending_token_balance: balance.ending,
             });
-            logger.info('subscription proration credit to customer', {
-              subscription: req.params.id,
-              prorationStart,
-              prorationEnd,
-              prorationRate,
-              totalProrationAmount,
-              customerCredit,
-            });
+            logger.info('subscription proration credit to customer', { subscription: req.params.id, credit });
           }
 
+          await subscription.update(updates);
+
           // 6. process the invoice as usual: push into queue
-          logger.info('subscription update invoice processing', { subscription: subscription.id, invoice: invoice.id });
           await invoiceQueue.pushAndWait({
             id: invoice.id,
             job: { invoiceId: invoice.id, retryOnError: false, waitForPayment: true },
           });
           logger.info('subscription update invoice processed', { subscription: subscription.id, invoice: invoice.id });
 
-          // client side
-          // 0. get invoice payment mode: credit/manual
-          // 1. wait for invoice.payment_succeeded event if payment mode is credit
-          // 2. popup to pay invoice if payment mode is manual
+          // wait for async events flushed
+          await sleep(3000);
+
+          // check if we have succeeded
+          await Promise.all([invoice.reload(), subscription.reload()]);
+
+          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,
+            });
+          } else {
+            await subscription.update({ status: 'past_due' });
+            logger.info('subscription past_due on invoice paid', {
+              subscription: subscription.id,
+              invoice: invoice.id,
+            });
+
+            const delegation = await isDelegationSufficientForPayment({
+              paymentMethod,
+              paymentCurrency,
+              userDid: customer.did,
+              amount: setup.amount.setup,
+            });
+            if (delegation.sufficient === false) {
+              if (['NO_DID_WALLET'].includes(delegation.reason as string)) {
+                connectAction = 'bind';
+              } else if (['NO_TOKEN', 'NO_ENOUGH_TOKEN'].includes(delegation.reason as string)) {
+                connectAction = 'collect';
+              } else {
+                connectAction = 'update';
+              }
+            }
+          }
         }
       } else if (req.body.billing_cycle_anchor === 'now') {
         // FIXME: handle billing cycle anchor change without any item change
+        await subscription.update(updates);
+      } else {
+        await subscription.update(updates);
       }
 
-      await subscription.update(updates);
-      return res.json(subscription);
+      return res.json({ ...subscription.toJSON(), connectAction });
     });
   } catch (err) {
     console.error(err);
@@ -723,6 +871,133 @@ router.put('/:id', auth, async (req, res) => {
   }
 });
 
+const getUpdateTable = async (subscription: Subscription) => {
+  // If we are from a pricing table
+  if (subscription.metadata.pricing_table_id) {
+    const table = await PricingTable.findByPk(subscription.metadata.pricing_table_id);
+    if (table) {
+      // @ts-ignore
+      return table.expand();
+    }
+  }
+
+  // if we are from upsell
+  const items = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+  if (items.length === 1) {
+    const expanded = await Price!.expand(
+      items.map((x) => x.toJSON()),
+      { upsell: true, product: true }
+    );
+    const exist = expanded.find((x) => x.price.type === 'recurring' && x.price.upsell?.upsells_to_id);
+    if (exist && exist.price.upsell?.upsells_to) {
+      // Fake a pricing table here
+      return {
+        active: true,
+        livemode: subscription.livemode,
+        name: 'Fake Pricing Table',
+        items: [
+          {
+            // Current item should always be the first
+            ...PricingTable.formatItem({
+              price_id: exist.price.id,
+              product_id: exist.price.product_id,
+            }),
+            price: exist.price,
+            product: exist.price.product,
+          },
+          {
+            // Upsell item comes next
+            ...PricingTable.formatItem({
+              price_id: exist.price.upsell.upsells_to_id,
+              product_id: exist.price.product_id,
+            }),
+            price: exist.price.upsell.upsells_to,
+            product: exist.price.product,
+          },
+        ],
+      };
+    }
+  }
+
+  return null;
+};
+
+// Check that the subscription is upgradable
+router.get('/:id/update', authPortal, async (req, res) => {
+  try {
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+    if (subscription.isActive() === false) {
+      return res.status(400).json({ error: 'Subscription is not active' });
+    }
+    if (subscription.isScheduledToCancel()) {
+      return res.status(400).json({ error: 'Subscription is scheduled to cancel' });
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (paymentMethod?.type === 'stripe') {
+      return res.status(400).json({ error: 'Update is not supported for subscriptions paid with stripe' });
+    }
+
+    const table = await getUpdateTable(subscription);
+    return res.json(table);
+  } catch (err) {
+    console.error(err);
+    return res.json(null);
+  }
+});
+
+// Simulate subscription update
+router.post('/:id/update', authPortal, async (req, res) => {
+  try {
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+    if (subscription.isActive() === false) {
+      return res.status(400).json({ error: 'Subscription is not active' });
+    }
+    if (subscription.isScheduledToCancel()) {
+      return res.status(400).json({ error: 'Subscription is scheduled to cancel' });
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (paymentMethod?.type === 'stripe') {
+      return res.status(400).json({ error: 'Update is not supported for subscriptions paid with stripe' });
+    }
+
+    const { error } = updateSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: `Subscription update request invalid: ${error.message}` });
+    }
+
+    // handle subscription item changes
+    if (!Array.isArray(req.body.items) || !req.body.items.length) {
+      return res.status(400).json({ error: 'Subscription update request invalid: items are empty' });
+    }
+
+    // validate the request
+    const { newItems } = await validateSubscriptionUpdateRequest(subscription, req.body.items);
+
+    // do the simulation
+    const setup = getSubscriptionCreateSetup(newItems, subscription.currency_id, 0);
+    const result = await createProration(subscription, setup);
+
+    return res.json({
+      setup,
+      total: result.total,
+      credit: result.credit,
+      prorations: result.prorations,
+      items: newItems,
+    });
+  } catch (err) {
+    console.error(err);
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 // FIXME: this should be removed in future
 // Clean up subscriptions that have invalid invoices and payments
 router.delete('/cleanup', auth, async (req, res) => {