payment-kit 1.13.73 → 1.13.74

package/api/src/routes/subscriptions.ts

@@ -1,21 +1,37 @@
+/* eslint-disable no-await-in-loop */
 import { isValid } from '@arcblock/did';
+import { BN } from '@ocap/util';
 import { Router } from 'express';
 import Joi from 'joi';
-import type { WhereOptions } from 'sequelize';
+import pick from 'lodash/pick';
+import uniq from 'lodash/uniq';
+import { Transaction, WhereOptions } from 'sequelize';
 
-import { subscriptionQueue } from '../jobs/subscription';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
-import { expandLineItems } from '../libs/session';
-import { formatMetadata } from '../libs/util';
+import {
+  expandLineItems,
+  getPriceUintAmountByCurrency,
+  getSubscriptionCreateSetup,
+  isLineItemAligned,
+} from '../libs/session';
+import { MAX_SUBSCRIPTION_ITEM_COUNT, formatMetadata } from '../libs/util';
+import { invoiceQueue } from '../queues/invoice';
+import { subscriptionQueue } from '../queues/subscription';
 import { Customer } from '../store/models/customer';
+import { Invoice } from '../store/models/invoice';
+import { InvoiceItem } from '../store/models/invoice-item';
 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 { Product } from '../store/models/product';
-import { Subscription } from '../store/models/subscription';
-import { SubscriptionItem } from '../store/models/subscription-item';
+import { Subscription, TSubscription } from '../store/models/subscription';
+import { SubscriptionItem, TSubscriptionItem } from '../store/models/subscription-item';
+import { UsageRecord } from '../store/models/usage-record';
+import { sequelize } from '../store/sequelize';
+import { ensureInvoiceAndItems } from './connect/shared';
 
 const router = Router();
 const auth = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -30,7 +46,7 @@ const authPortal = authenticate<Subscription>({
   },
 });
 
-const updateStripSubscription = async (doc: Subscription, updates: any) => {
+const updateStripeSubscription = async (doc: Subscription, updates: any) => {
   if (doc.payment_details?.stripe?.subscription_id) {
     const method = await PaymentMethod.findByPk(doc.default_payment_method_id);
     if (method && method.type === 'stripe') {
@@ -222,7 +238,7 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not recoverable from cancellation' });
   }
 
-  await updateStripSubscription(doc, { cancel_at_period_end: false });
+  await updateStripeSubscription(doc, { cancel_at_period_end: false });
   await doc.update({ cancel_at_period_end: false });
 
   // reschedule jobs
@@ -256,7 +272,7 @@ router.put('/:id/pause', auth, async (req, res) => {
 
   const timestamp = type === 'custom' ? dayjs(resumesAt).unix() : 0;
 
-  await updateStripSubscription(doc, {
+  await updateStripeSubscription(doc, {
     pause_collection: {
       resumes_at: timestamp || null,
       behavior: behavior || 'keep_as_draft',
@@ -292,7 +308,7 @@ router.put('/:id/resume', auth, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not paused' });
   }
 
-  await updateStripSubscription(doc, { pause_collection: null });
+  await updateStripeSubscription(doc, { pause_collection: null });
   await doc.update({ status: 'active', pause_collection: undefined });
 
   subscriptionQueue
@@ -303,16 +319,421 @@ router.put('/:id/resume', auth, async (req, res) => {
   return res.json(doc);
 });
 
+const isValidSubscriptionItemChange = (item: TSubscriptionItem & { [key: string]: any }) => {
+  if (item.deleted) {
+    if (!item.id) {
+      throw new Error('You must delete subscription item with id');
+    }
+  } else if (item.clear_usage) {
+    if (!item.id) {
+      throw new Error('You must clear usage of subscription item with id');
+    }
+    if (!item.deleted) {
+      throw new Error('You must clear usage of subscription item on delete');
+    }
+  } else {
+    if (!item.price_id) {
+      throw new Error('You must add subscription item with price_id');
+    }
+    if (!item.quantity) {
+      throw new Error('You must add subscription item with quantity');
+    }
+  }
+
+  return true;
+};
+
+// TODO: 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;
+  }[];
+}>({
+  description: Joi.string().min(1).optional(),
+  metadata: Joi.any().optional(),
+  payment_behavior: Joi.string().allow('allow_incomplete', 'error_if_incomplete', 'pending_if_incomplete').optional(),
+  proration_behavior: Joi.string().allow('always_invoice', 'create_prorations', 'none').optional(),
+  billing_cycle_anchor: Joi.string().allow('now', 'unchanged').optional(),
+  items: Joi.array()
+    .items(
+      Joi.object({
+        id: Joi.string().optional(),
+        price_id: Joi.string().optional(),
+        quantity: Joi.number().optional(),
+        deleted: Joi.boolean().optional(),
+        clear_usage: Joi.boolean().optional(),
+      })
+    )
+    .optional()
+    .default([]),
+});
+// eslint-disable-next-line consistent-return
 router.put('/:id', auth, async (req, res) => {
+  logger.debug('subscription update request', { subscription: req.params.id, body: req.body });
+  try {
+    const { error } = updateSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: `Subscription update request invalid: ${error.message}` });
+    }
+
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+    if (['trailing', 'active'].includes(subscription.status) === false) {
+      return res.status(400).json({ error: 'Subscription can only be updated when in trailing or active mode' });
+    }
+
+    const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
+    if (!lastInvoice) {
+      throw new Error('Subscription should have latest invoice');
+    }
+    const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
+    if (!paymentCurrency) {
+      throw new Error('Subscription should have payment currency');
+    }
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error('Subscription should have customer');
+    }
+
+    // handle updates
+    const updates: Partial<TSubscription> = {};
+    if (req.body.metadata) {
+      updates.metadata = formatMetadata(req.body.metadata);
+    }
+    if (req.body.description) {
+      updates.description = req.body.description;
+    }
+    if (req.body.payment_behavior) {
+      updates.payment_behavior = req.body.payment_behavior;
+    }
+    if (req.body.proration_behavior) {
+      updates.proration_behavior = req.body.proration_behavior;
+    }
+
+    let invoice: Invoice;
+
+    await sequelize.transaction({ isolationLevel: Transaction.ISOLATION_LEVELS.READ_UNCOMMITTED }, async () => {
+      // 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())
+        );
+        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) {
+          if (item.deleted) {
+            if (item.clear_usage) {
+              await UsageRecord.destroy({ where: { subscription_item_id: item.id } });
+              logger.info('subscription item usage cleared', { subscription: req.params.id, item: item.id });
+            }
+            await SubscriptionItem.destroy({ where: { id: item.id } });
+            logger.info('subscription item deleted', { subscription: req.params.id, item: item.id });
+          } else {
+            const exist = existingItems.find((x) => x.id === item.id);
+            if (exist) {
+              await exist.update(pick(item, ['quantity', 'metadata', 'billing_thresholds']));
+              logger.info('subscription item updated', { subscription: req.params.id, item: item.id });
+            } else {
+              await SubscriptionItem.create({
+                ...item,
+                livemode: subscription.livemode,
+                subscription_id: subscription.id,
+              });
+              logger.info('subscription item added', { subscription: req.params.id, item: item.id });
+            }
+          }
+        }
+
+        // update subscription period settings
+        // HINT: if we are adding new items, we need to reset the anchor to now
+        const setup = getSubscriptionCreateSetup(newItems, paymentCurrency.id, 0);
+        if (addedItems.some((x) => x.price.type === 'recurring')) {
+          updates.pending_invoice_item_interval = setup.recurring;
+          updates.current_period_start = setup.period.start;
+          updates.current_period_end = setup.period.end;
+          updates.billing_cycle_anchor = setup.cycle.anchor;
+          logger.info('subscription updates on reset anchor', { subscription: req.params.id, updates });
+        }
+
+        // handle proration
+        const prorationBehavior = updates.proration_behavior || subscription.proration_behavior || 'none';
+        if (prorationBehavior === 'create_prorations') {
+          // 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);
+
+          // 2. create new invoice: amount according to new subscription items
+          // 3. create new invoice items: amount according to new subscription items
+          const result = await ensureInvoiceAndItems({
+            customer,
+            subscription,
+            trailing: false,
+            metered: false,
+            lineItems: newItems,
+            props: {
+              status: 'draft',
+              livemode: subscription.livemode,
+              description: 'Subscription update',
+              statement_descriptor: lastInvoice.statement_descriptor,
+              period_start: setup.period.start,
+              period_end: setup.period.end,
+              auto_advance: true, // FIXME: this should be calculated dynamically
+              billing_reason: 'subscription_update',
+              total: setup.amount.setup,
+              currency_id: paymentCurrency.id,
+              default_payment_method_id: subscription.default_payment_method_id,
+              custom_fields: lastInvoice.custom_fields || [],
+              footer: lastInvoice.footer || '',
+            } as Invoice,
+          });
+          invoice = result.invoice;
+          updates.latest_invoice_id = invoice.id;
+          logger.info('subscription update invoice created', { subscription: req.params.id, invoice: invoice.id });
+
+          // 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({
+                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();
+            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,
+            });
+          } else {
+            const customerCredit = totalProrationAmount.sub(invoiceTotal).toString();
+            const balance = await customer.increaseTokenBalance(paymentCurrency.id, customerCredit);
+            await invoice.update({
+              status: 'open',
+              subtotal: '0',
+              subtotal_excluding_tax: '0',
+              total: '0',
+              amount_due: '0',
+              amount_remaining: '0',
+              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,
+            });
+          }
+
+          // 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
+        }
+      } else if (req.body.billing_cycle_anchor === 'now') {
+        // FIXME: handle billing cycle anchor change without any item change
+      }
+
+      await subscription.update(updates);
+
+      return res.json({ subscription, invoice });
+    });
+  } catch (err) {
+    console.error(err);
+    return res.status(500).json({ code: err.code, error: err.message });
+  }
+});
+
+// FIXME: this should be removed in future
+// Clean up subscriptions that have invalid invoices and payments
+router.delete('/cleanup', auth, async (_, res) => {
+  const subscriptions = await Subscription.findAll();
+  const canceled: string[] = [];
+
+  await Promise.all(
+    subscriptions.map(async (x) => {
+      const invoices = await Invoice.findAll({ where: { subscription_id: x.id, status: 'uncollectible' } });
+      if (invoices.length <= 1) {
+        return;
+      }
+
+      canceled.push(x.id);
+
+      const now = dayjs().unix();
+      if (x.status === 'active' || x.status === 'trialing') {
+        await x.update({
+          status: 'canceled',
+          canceled_at: now,
+          cancelation_details: {
+            reason: 'too_many_uncollectible_invoices',
+            feedback: 'other',
+            comment: `Too many uncollectible invoices: ${invoices.length}`,
+          },
+        });
+      }
+      await Invoice.update({ status: 'void' }, { where: { id: invoices.map((i) => i.id) } });
+      await PaymentIntent.update(
+        { status: 'canceled', canceled_at: now, cancellation_reason: 'abandoned' },
+        { where: { invoice_id: invoices.map((i) => i.id) } }
+      );
+      logger.warn('subscription canceled since too much uncollectible invoices', {
+        subscription: x.id,
+        count: invoices.length,
+      });
+    })
+  );
+
+  res.json(canceled);
+});
+
+// Delete subscription and all related data
+router.delete('/:id', auth, async (req, res) => {
+  if (process.env.BLOCKLET_MODE === 'production') {
+    return res.status(404).json({ error: 'Subscription delete not allowed in production' });
+  }
+
   const doc = await Subscription.findByPk(req.params.id);
 
   if (!doc) {
     return res.status(404).json({ error: 'Subscription not found' });
   }
 
-  if (req.body.metadata) {
-    await doc.update({ metadata: formatMetadata(req.body.metadata) });
-  }
+  await InvoiceItem.destroy({ where: { subscription_id: doc.id } });
+  await Invoice.destroy({ where: { subscription_id: doc.id } });
+  const items = await SubscriptionItem.findAll({ where: { subscription_id: doc.id }, attributes: ['id'] });
+  await UsageRecord.destroy({ where: { subscription_item_id: items.map((x) => x.id) } });
+  await SubscriptionItem.destroy({ where: { subscription_id: doc.id } });
+  await doc.destroy();
+  logger.info('subscription deleted', { subscription: req.params.id });
 
   return res.json(doc);
 });

package/api/src/store/migrate.ts

@@ -19,7 +19,6 @@ export default function migrate() {
 
 type ColumnChanges = Record<string, { name: string; field: any }[]>;
 export async function safeApplyColumnChanges(context: QueryInterface, changes: ColumnChanges) {
-  console.info('safeApplyColumnChanges', changes);
   for (const [table, columns] of Object.entries(changes)) {
     const schema = await context.describeTable(table);
     for (const { name, field } of columns) {

package/api/src/store/migrations/20231204-subupdate.ts

@@ -0,0 +1,50 @@
+/* eslint-disable no-await-in-loop */
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    subscriptions: [
+      {
+        name: 'proration_behavior',
+        field: { type: DataTypes.ENUM('always_invoice', 'create_prorations', 'none'), defaultValue: 'none' },
+      },
+      {
+        name: 'payment_behavior',
+        field: {
+          type: DataTypes.ENUM(
+            'default_incomplete',
+            'allow_incomplete',
+            'error_if_incomplete',
+            'pending_if_incomplete'
+          ),
+          defaultValue: 'default_incomplete',
+        },
+      },
+    ],
+    customers: [
+      {
+        name: 'token_balance',
+        // NOTE: we must use stringified empty object as default value here
+        field: { type: DataTypes.JSON, defaultValue: '{}' },
+      },
+    ],
+    invoices: [
+      {
+        name: 'starting_token_balance',
+        field: { type: DataTypes.JSON, defaultValue: '{}' },
+      },
+      {
+        name: 'ending_token_balance',
+        field: { type: DataTypes.JSON, defaultValue: '{}' },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('subscriptions', 'proration_behavior');
+  await context.removeColumn('subscriptions', 'payment_behavior');
+  await context.removeColumn('customers', 'token_balance');
+};

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

@@ -465,6 +465,10 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
       ...options,
     });
   }
+
+  public isImmutable() {
+    return ['complete', 'expired'].includes(this.status);
+  }
 }
 
 export type TCheckoutSession = InferAttributes<CheckoutSession>;

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

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/lines-between-class-members */
+import { BN } from '@ocap/util';
+import cloneDeep from 'lodash/cloneDeep';
 import padStart from 'lodash/padStart';
 import {
   CreationOptional,
@@ -11,6 +13,7 @@ import {
 } from 'sequelize';
 
 import { createEvent } from '../../libs/audit';
+import CustomError from '../../libs/error';
 import { createIdGenerator } from '../../libs/util';
 import type { CustomerAddress, CustomerShipping } from './types';
 
@@ -30,7 +33,8 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   declare address?: CustomerAddress;
   declare shipping?: CustomerShipping;
 
-  declare balance?: string;
+  declare balance?: string; // synced with stripe
+  declare token_balance?: Record<string, string>; // token balances
   declare currency_id?: string;
   declare delinquent: boolean;
   declare discount_id?: string;
@@ -150,22 +154,55 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
     return `${this.invoice_prefix}-${padStart(sequence.toString(), 4, '0')}`;
   }
 
+  public async decreaseTokenBalance(currencyId: string, amount: string) {
+    const tokens = this.token_balance || {};
+    const balance = tokens[currencyId] || '0';
+    if (new BN(balance).lt(new BN(amount))) {
+      throw new CustomError('INSUFFICIENT_BALANCE', 'Insufficient customer balance');
+    }
+
+    const starting = cloneDeep(tokens);
+    // NOTE: new object is required to trick sequelize to update the field
+    const ending = { ...starting, [currencyId]: new BN(balance).sub(new BN(amount)).toString() };
+    await this.update({ token_balance: ending });
+    return { starting, ending };
+  }
+
+  public async increaseTokenBalance(currencyId: string, amount: string) {
+    const tokens = this.token_balance || {};
+    const balance = tokens[currencyId] || '0';
+    const starting = cloneDeep(tokens);
+    // NOTE: new object is required to trick sequelize to update the field
+    const ending = { ...starting, [currencyId]: new BN(balance).add(new BN(amount)).toString() };
+    await this.update({ token_balance: ending });
+    return { starting, ending };
+  }
+
   public static initialize(sequelize: any) {
-    this.init(Customer.GENESIS_ATTRIBUTES, {
-      sequelize,
-      modelName: 'Customer',
-      tableName: 'customers',
-      createdAt: 'created_at',
-      updatedAt: 'updated_at',
-      hooks: {
-        afterCreate: (model: Customer, options) =>
-          createEvent('Customer', 'customer.created', model, options).catch(console.error),
-        afterUpdate: (model: Customer, options) =>
-          createEvent('Customer', 'customer.updated', model, options).catch(console.error),
-        afterDestroy: (model: Customer, options) =>
-          createEvent('Customer', 'customer.deleted', model, options).catch(console.error),
+    this.init(
+      {
+        ...Customer.GENESIS_ATTRIBUTES,
+        token_balance: {
+          type: DataTypes.JSON,
+          defaultValue: {},
+        },
       },
-    });
+      {
+        sequelize,
+        modelName: 'Customer',
+        tableName: 'customers',
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        hooks: {
+          afterCreate: (model: Customer, options) =>
+            createEvent('Customer', 'customer.created', model, options).catch(console.error),
+          afterUpdate: (model: Customer, options) =>
+            createEvent('Customer', 'customer.updated', model, options).catch(console.error),
+          afterDestroy: (model: Customer, options) =>
+            createEvent('Customer', 'customer.deleted', model, options).catch(console.error),
+        },
+      }
+    );
   }
 
   public static associate(models: any) {

package/api/src/store/models/invoice-item.ts

@@ -38,7 +38,12 @@ export class InvoiceItem extends Model<InferAttributes<InvoiceItem>, InferCreati
   declare discounts: string[];
 
   declare proration: boolean;
-  declare proration_details: any;
+  declare proration_details: {
+    credited_items?: {
+      invoice_id: string;
+      invoice_line_items: string[];
+    };
+  };
 
   declare metadata: Record<string, any>;