payment-kit 1.20.10 → 1.20.12

package/api/src/store/migrations/20250910-timestamp-fields.ts

@@ -0,0 +1,116 @@
+import { DataTypes } from 'sequelize';
+import { Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  const isColumnInteger = async (tableName: string, columnName: string): Promise<boolean> => {
+    const [results] = await context.sequelize.query(`PRAGMA table_info(${tableName})`);
+    const columnInfo = (results as any[]).find((col: any) => col.name === columnName);
+    return columnInfo && columnInfo.type.toUpperCase() === 'INTEGER';
+  };
+
+  const migrateDateToInteger = async (
+    tableName: string,
+    columnName: string,
+    options: { allowNull: boolean; convertAllRows?: boolean } = { allowNull: true }
+  ) => {
+    if (await isColumnInteger(tableName, columnName)) {
+      return;
+    }
+
+    const tempColumnName = `${columnName}_new`;
+
+    await context.addColumn(tableName, tempColumnName, {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    });
+
+    const updateQuery = options.convertAllRows
+      ? `UPDATE ${tableName} SET ${tempColumnName} = strftime('%s', ${columnName})`
+      : `UPDATE ${tableName} SET ${tempColumnName} = strftime('%s', ${columnName}) WHERE ${columnName} IS NOT NULL`;
+
+    await context.sequelize.query(updateQuery);
+
+    // Replace old column
+    await context.removeColumn(tableName, columnName);
+    await context.renameColumn(tableName, tempColumnName, columnName);
+
+    // Apply final column type and constraints
+    await context.changeColumn(tableName, columnName, {
+      type: DataTypes.INTEGER,
+      allowNull: options.allowNull,
+    });
+  };
+
+  // Define columns to migrate
+  const migrations = [
+    { table: 'promotion_codes', column: 'expires_at', allowNull: true },
+    { table: 'coupons', column: 'redeem_by', allowNull: true },
+    { table: 'discounts', column: 'start', allowNull: false, convertAllRows: true },
+    { table: 'discounts', column: 'end', allowNull: true },
+  ];
+
+  // Execute migrations
+  for (const migration of migrations) {
+    // eslint-disable-next-line no-await-in-loop
+    await migrateDateToInteger(migration.table, migration.column, {
+      allowNull: migration.allowNull,
+      convertAllRows: migration.convertAllRows,
+    });
+  }
+};
+
+export const down: Migration = async ({ context }) => {
+  const isColumnDate = async (tableName: string, columnName: string): Promise<boolean> => {
+    const [results] = await context.sequelize.query(`PRAGMA table_info(${tableName})`);
+    const columnInfo = (results as any[]).find((col: any) => col.name === columnName);
+    return columnInfo && (columnInfo.type.toUpperCase() === 'DATE' || columnInfo.type.toUpperCase() === 'DATETIME');
+  };
+
+  const migrateIntegerToDate = async (
+    tableName: string,
+    columnName: string,
+    options: { allowNull: boolean; convertAllRows?: boolean } = { allowNull: true }
+  ) => {
+    if (await isColumnDate(tableName, columnName)) {
+      return;
+    }
+
+    const tempColumnName = `${columnName}_old`;
+
+    // Add temporary DATE column
+    await context.addColumn(tableName, tempColumnName, {
+      type: DataTypes.DATE,
+      allowNull: true,
+    });
+
+    const updateQuery = options.convertAllRows
+      ? `UPDATE ${tableName} SET ${tempColumnName} = datetime(${columnName}, 'unixepoch')`
+      : `UPDATE ${tableName} SET ${tempColumnName} = datetime(${columnName}, 'unixepoch') WHERE ${columnName} IS NOT NULL`;
+
+    await context.sequelize.query(updateQuery);
+
+    // Replace old column
+    await context.removeColumn(tableName, columnName);
+    await context.renameColumn(tableName, tempColumnName, columnName);
+
+    await context.changeColumn(tableName, columnName, {
+      type: DataTypes.DATE,
+      allowNull: options.allowNull,
+    });
+  };
+
+  // Define columns to rollback (reverse order)
+  const rollbacks = [
+    { table: 'discounts', column: 'end', allowNull: true },
+    { table: 'discounts', column: 'start', allowNull: false, convertAllRows: true },
+    { table: 'coupons', column: 'redeem_by', allowNull: true },
+    { table: 'promotion_codes', column: 'expires_at', allowNull: true },
+  ];
+  for (const rollback of rollbacks) {
+    // eslint-disable-next-line no-await-in-loop
+    await migrateIntegerToDate(rollback.table, rollback.column, {
+      allowNull: rollback.allowNull,
+      convertAllRows: rollback.convertAllRows,
+    });
+  }
+};

package/api/src/store/migrations/20250916-add-description-fields.ts

@@ -0,0 +1,30 @@
+import { DataTypes } from 'sequelize';
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    coupons: [
+      {
+        name: 'description',
+        field: {
+          type: DataTypes.TEXT,
+          allowNull: true,
+        },
+      },
+    ],
+    promotion_codes: [
+      {
+        name: 'description',
+        field: {
+          type: DataTypes.TEXT,
+          allowNull: true,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('coupons', 'description');
+  await context.removeColumn('promotion_codes', 'description');
+};

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

@@ -196,6 +196,14 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
 
   declare cross_sell_behavior?: LiteralUnion<'auto' | 'required', string>;
 
+  // FIXME: Only exist on creation
+  declare discounts?: Array<{
+    coupon?: string;
+    promotion_code?: string;
+    discount_amount?: string;
+    verification_method?: string;
+    verification_data?: Record<string, any>;
+  }>;
   declare fulfillment_status?: LiteralUnion<
     | 'pending'
     | 'processing'
@@ -425,6 +433,10 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
     this.init(
       {
         ...CheckoutSession.GENESIS_ATTRIBUTES,
+        discounts: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
         payment_intent_data: {
           type: DataTypes.JSON,
           allowNull: true,

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

@@ -1,8 +1,13 @@
 /* eslint-disable @typescript-eslint/lines-between-class-members */
 import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
 import type { LiteralUnion } from 'type-fest';
+import { fromTokenToUnit } from '@ocap/util';
 
-import { createCodeGenerator } from '../../libs/util';
+import { createEvent } from '../../libs/audit';
+import { createCodeGenerator, formatMetadata } from '../../libs/util';
+import { trimDecimals } from '../../libs/math-utils';
+import logger from '../../libs/logger';
+import type { TPaymentCurrency } from './payment-currency';
 
 const nextId = createCodeGenerator('', 8);
 
@@ -10,6 +15,7 @@ const nextId = createCodeGenerator('', 8);
 export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttributes<Coupon>> {
   declare id: CreationOptional<string>;
   declare livemode: boolean;
+  declare locked: CreationOptional<boolean>;
 
   declare amount_off: string;
   declare percent_off: number;
@@ -22,23 +28,32 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
 
   declare name: string;
 
+  declare description?: string;
+
   declare metadata: Record<string, any>;
 
   declare applies_to?: {
     products: string[];
   };
 
-  declare currency_options?: Record<string, number>;
+  declare currency_options?: Record<
+    string,
+    {
+      amount_off: string;
+    }
+  >;
 
   declare max_redemptions?: number;
 
-  declare redeem_by?: Date;
+  declare redeem_by?: number;
 
   declare times_redeemed?: number;
 
   declare valid?: boolean;
+  declare created_via: LiteralUnion<'api' | 'dashboard' | 'portal', string>;
 
   declare created_at: CreationOptional<Date>;
+
   declare updated_at: CreationOptional<Date>;
 
   public static readonly GENESIS_ATTRIBUTES = {
@@ -52,6 +67,10 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
       type: DataTypes.BOOLEAN,
       allowNull: false,
     },
+    locked: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
     amount_off: {
       type: DataTypes.STRING(32),
       defaultValue: '0',
@@ -63,18 +82,25 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
     currency_id: {
       type: DataTypes.STRING(15),
       allowNull: false,
+      defaultValue: '',
     },
     duration: {
       type: DataTypes.ENUM('forever', 'once', 'repeating'),
+      allowNull: false,
     },
     duration_in_months: {
       type: DataTypes.INTEGER,
       allowNull: false,
+      defaultValue: 0,
     },
     name: {
       type: DataTypes.STRING(64),
       allowNull: false,
     },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+    },
     applies_to: {
       type: DataTypes.JSON,
       allowNull: true,
@@ -88,7 +114,7 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
       allowNull: true,
     },
     redeem_by: {
-      type: DataTypes.DATE,
+      type: DataTypes.INTEGER,
       allowNull: true,
     },
     times_redeemed: {
@@ -103,6 +129,10 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
       type: DataTypes.JSON,
       allowNull: true,
     },
+    created_via: {
+      type: DataTypes.ENUM('api', 'dashboard', 'portal'),
+      allowNull: false,
+    },
     created_at: {
       type: DataTypes.DATE,
       defaultValue: DataTypes.NOW,
@@ -122,6 +152,14 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
       tableName: 'coupons',
       createdAt: 'created_at',
       updatedAt: 'updated_at',
+      hooks: {
+        afterCreate: (model: Coupon, options) =>
+          createEvent('Coupon', 'coupon.created', model, options).catch(console.error),
+        afterUpdate: (model: Coupon, options) =>
+          createEvent('Coupon', 'coupon.updated', model, options).catch(console.error),
+        afterDestroy: (model: Coupon, options) =>
+          createEvent('Coupon', 'coupon.deleted', model, options).catch(console.error),
+      },
     });
   }
 
@@ -132,6 +170,108 @@ export class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttribut
       as: 'currency',
     });
   }
+
+  public static formatBeforeSave(coupon: Partial<TCoupon>) {
+    if (coupon.metadata) {
+      coupon.metadata = formatMetadata(coupon.metadata);
+    }
+
+    if (coupon.max_redemptions) {
+      coupon.max_redemptions = Number(coupon.max_redemptions);
+    }
+
+    if (coupon.times_redeemed) {
+      coupon.times_redeemed = Number(coupon.times_redeemed);
+    }
+
+    if (coupon.duration === 'repeating') {
+      coupon.duration_in_months = Number(coupon.duration_in_months || 0);
+    }
+
+    return coupon;
+  }
+
+  public static async insert(coupon: Partial<TCoupon>) {
+    const formattedData = this.formatBeforeSave({
+      locked: false,
+      times_redeemed: 0,
+      valid: true,
+      metadata: {},
+      amount_off: '0',
+      currency_options: {},
+      currency_id: '',
+      duration_in_months: 0,
+      ...coupon,
+    });
+    logger.info('Formatted data', { formattedData });
+    try {
+      return await this.create(formattedData as any);
+    } catch (error) {
+      logger.error('Coupon creation error details:', {
+        error: error.message,
+        formattedData,
+        validationErrors: error.errors || [],
+        sqlMessage: error.original?.message || 'No SQL message',
+      });
+      throw error;
+    }
+  }
+
+  public async isUsed() {
+    const { Discount } = this.sequelize.models;
+    const discountCount = await Discount!.count({
+      where: { coupon_id: this.id },
+    });
+
+    if (discountCount > 0) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public async getAppliedProducts() {
+    if (!this.applies_to || !this.applies_to?.products) {
+      return [];
+    }
+    const { Product } = this.sequelize.models;
+    const productsWithPrices = await Promise.all(
+      // @ts-ignore
+      this.applies_to.products.map((productId) => Product!.expand(productId))
+    );
+    return productsWithPrices;
+  }
+
+  /**
+   * Format currency options for storage - convert unit amounts to token amounts
+   */
+  public static formatCurrencyOptions(
+    currencyOptions: Record<string, { amount_off: string }>,
+    currencies: TPaymentCurrency[]
+  ): Record<
+    string,
+    {
+      amount_off: string;
+    }
+  > {
+    const formatted: Record<string, { amount_off: string }> = {};
+
+    for (const [currencyId, amountInfo] of Object.entries(currencyOptions || {})) {
+      const currency = currencies.find((c) => c.id === currencyId);
+      if (!currency) {
+        throw new Error(`currency ${currencyId} used in coupon not found or inactive`);
+      }
+
+      formatted[currencyId] = {
+        amount_off: fromTokenToUnit(
+          trimDecimals(amountInfo.amount_off || '0', currency.decimal),
+          currency.decimal
+        ).toString(),
+      };
+    }
+
+    return formatted;
+  }
 }
 
 export type TCoupon = InferAttributes<Coupon>;

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

@@ -20,7 +20,11 @@ export class Discount extends Model<InferAttributes<Discount>, InferCreationAttr
   declare invoice_item_id?: string;
 
   declare start: number;
-  declare end: number;
+  declare end: number | null;
+
+  declare verification_method?: string;
+  declare verification_data?: Record<string, any>;
+  declare metadata?: Record<string, any>;
 
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
@@ -65,11 +69,19 @@ export class Discount extends Model<InferAttributes<Discount>, InferCreationAttr
       allowNull: true,
     },
     start: {
-      type: DataTypes.DATE,
+      type: DataTypes.INTEGER,
       allowNull: false,
     },
     end: {
-      type: DataTypes.DATE,
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    verification_method: {
+      type: DataTypes.STRING(50),
+      allowNull: true,
+    },
+    verification_data: {
+      type: DataTypes.JSON,
       allowNull: true,
     },
     metadata: {
@@ -98,18 +110,19 @@ export class Discount extends Model<InferAttributes<Discount>, InferCreationAttr
     });
   }
 
-  // FIXME:
   public static associate(models: any) {
-    this.hasOne(models.Customer, {
-      sourceKey: 'customer_id',
-      foreignKey: 'id',
+    this.belongsTo(models.Customer, {
+      foreignKey: 'customer_id',
       as: 'customer',
     });
-    this.hasOne(models.Coupon, {
-      sourceKey: 'coupon_id',
-      foreignKey: 'id',
+    this.belongsTo(models.Coupon, {
+      foreignKey: 'coupon_id',
       as: 'coupon',
     });
+    this.belongsTo(models.PromotionCode, {
+      foreignKey: 'promotion_code_id',
+      as: 'promotionCode',
+    });
   }
 }
 

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

@@ -1,5 +1,5 @@
 import { CheckoutSession, TCheckoutSession } from './checkout-session';
-import { Coupon } from './coupon';
+import { Coupon, TCoupon } from './coupon';
 import { Customer, TCustomer } from './customer';
 import { Discount } from './discount';
 import { Event, TEvent } from './event';
@@ -16,7 +16,7 @@ import { Payout, TPayout } from './payout';
 import { Price, TPrice } from './price';
 import { PricingTable, TPricingTable } from './pricing-table';
 import { Product, TProduct } from './product';
-import { PromotionCode } from './promotion-code';
+import { PromotionCode, TPromotionCode } from './promotion-code';
 import { Refund, TRefund } from './refund';
 import { SetupIntent, TSetupIntent } from './setup-intent';
 import { Subscription, TSubscription } from './subscription';
@@ -321,3 +321,14 @@ export type CreditGrantSummary = {
   remainingAmount: string;
   grantCount: number;
 };
+
+export type TCouponExpanded = TCoupon & {
+  object: 'coupon';
+  applied_products?: TProduct[];
+  promotion_codes?: TPromotionCode[];
+};
+
+export type TPromotionCodeExpanded = TPromotionCode & {
+  object: 'promotion_code';
+  coupon?: TCoupon;
+};