payment-kit 1.20.11 → 1.20.13

package/api/src/store/models/promotion-code.ts

@@ -1,7 +1,22 @@
 /* eslint-disable @typescript-eslint/lines-between-class-members */
-import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+import {
+  CreationOptional,
+  DataTypes,
+  InferAttributes,
+  InferCreationAttributes,
+  Model,
+  Op,
+  FindOptions,
+  WhereOptions,
+} from 'sequelize';
+import { fromTokenToUnit } from '@ocap/util';
 
-import { createIdGenerator } from '../../libs/util';
+import type { LiteralUnion } from 'type-fest';
+import { createIdGenerator, formatMetadata } from '../../libs/util';
+import { trimDecimals } from '../../libs/math-utils';
+import type { NFTConfig, Restrictions, VCConfig, VerificationType } from './types';
+import type { TPaymentCurrency } from './payment-currency';
+import { createEvent } from '../../libs/audit';
 
 const nextId = createIdGenerator('promo', 24);
 
@@ -11,27 +26,33 @@ export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCr
   declare id: CreationOptional<string>;
   declare livemode: boolean;
   declare active: boolean;
+  declare locked: CreationOptional<boolean>;
 
   declare code: string;
 
+  declare description?: string;
+
   declare coupon_id: string;
 
   // redeem conditions
   declare max_redemptions?: number;
-  declare restrictions?: {
-    currency_options?: Record<string, number>;
-    first_time_transaction?: boolean;
-    minimum_amount?: number;
-    minimum_amount_currency?: string;
-  };
+  declare restrictions?: Restrictions;
   declare customer_id?: string;
 
   declare times_redeemed?: number;
 
-  declare expires_at: CreationOptional<Date>;
+  declare expires_at?: number;
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
 
+  // Separated verification configurations
+  declare verification_type?: VerificationType;
+  declare nft_config?: NFTConfig;
+  declare vc_config?: VCConfig;
+  declare customer_dids?: string[];
+  declare metadata?: Record<string, any>;
+  declare created_via: LiteralUnion<'api' | 'dashboard' | 'portal', string>;
+
   public static readonly GENESIS_ATTRIBUTES = {
     id: {
       type: DataTypes.STRING(30),
@@ -43,6 +64,10 @@ export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCr
       type: DataTypes.BOOLEAN,
       allowNull: false,
     },
+    locked: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
     active: {
       type: DataTypes.BOOLEAN,
       defaultValue: true,
@@ -51,9 +76,13 @@ export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCr
       type: DataTypes.STRING(16),
       allowNull: false,
     },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+    },
     coupon_id: {
       type: DataTypes.STRING(30),
-      allowNull: true,
+      allowNull: false,
     },
     max_redemptions: {
       type: DataTypes.INTEGER,
@@ -75,8 +104,11 @@ export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCr
       type: DataTypes.JSON,
       allowNull: true,
     },
+    created_via: {
+      type: DataTypes.ENUM('api', 'dashboard', 'portal'),
+    },
     expires_at: {
-      type: DataTypes.DATE,
+      type: DataTypes.INTEGER,
       allowNull: true,
     },
     created_at: {
@@ -92,13 +124,47 @@ export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCr
   };
 
   public static initialize(sequelize: any) {
-    this.init(PromotionCode.GENESIS_ATTRIBUTES, {
-      sequelize,
-      modelName: 'PromotionCode',
-      tableName: 'promotion_codes',
-      createdAt: 'created_at',
-      updatedAt: 'updated_at',
-    });
+    this.init(
+      {
+        ...PromotionCode.GENESIS_ATTRIBUTES,
+        verification_type: {
+          type: DataTypes.ENUM('code', 'nft', 'vc', 'user_restricted'),
+          defaultValue: 'code',
+          allowNull: false,
+        },
+        nft_config: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+        vc_config: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+        customer_dids: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+        metadata: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+      },
+      {
+        sequelize,
+        modelName: 'PromotionCode',
+        tableName: 'promotion_codes',
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        hooks: {
+          afterCreate: (model: PromotionCode, options) =>
+            createEvent('PromotionCode', 'promotion_code.created', model, options).catch(console.error),
+          afterUpdate: (model: PromotionCode, options) =>
+            createEvent('PromotionCode', 'promotion_code.updated', model, options).catch(console.error),
+          afterDestroy: (model: PromotionCode, options) =>
+            createEvent('PromotionCode', 'promotion_code.deleted', model, options).catch(console.error),
+        },
+      }
+    );
   }
 
   public static associate(models: any) {
@@ -107,6 +173,217 @@ export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCr
       as: 'coupon',
     });
   }
+
+  public static formatBeforeSave(promotionCode: Partial<TPromotionCode>) {
+    if (promotionCode.metadata) {
+      promotionCode.metadata = formatMetadata(promotionCode.metadata);
+    }
+
+    if (promotionCode.max_redemptions) {
+      promotionCode.max_redemptions = Number(promotionCode.max_redemptions);
+    }
+
+    if (promotionCode.times_redeemed) {
+      promotionCode.times_redeemed = Number(promotionCode.times_redeemed);
+    }
+
+    return promotionCode;
+  }
+
+  /**
+   * Find promotion code by multiple criteria:
+   * - id: promotion code ID
+   * - code: promotion code string
+   * - nft_address: NFT contract address (when verification_type is 'nft')
+   * - vc_role: VC role (when verification_type is 'vc')
+   * - userDid: user DID (when verification_type is 'user_restricted')
+   */
+  public static findByMultipleCriteria(
+    searchValue: string,
+    options: FindOptions<PromotionCode> = {},
+    verificationType: VerificationType | null = null
+  ) {
+    const whereConditions = [{ id: searchValue }, { code: searchValue }] as WhereOptions[];
+
+    // Add NFT address search condition
+    if (verificationType === 'nft' || !verificationType) {
+      whereConditions.push({
+        verification_type: 'nft',
+        'nft_config.addresses': {
+          [Op.contains]: [searchValue],
+        },
+      });
+    }
+
+    // Add VC role search condition
+    if (verificationType === 'vc' || !verificationType) {
+      whereConditions.push({
+        verification_type: 'vc',
+        'vc_config.roles': {
+          [Op.contains]: [searchValue],
+        },
+      });
+    }
+
+    // Add user DID search condition
+    if (verificationType === 'user_restricted' || !verificationType) {
+      whereConditions.push({
+        verification_type: 'user_restricted',
+        customer_dids: {
+          [Op.contains]: [searchValue],
+        },
+      });
+    }
+
+    return this.findOne({
+      where: { [Op.or]: whereConditions },
+      ...options,
+    });
+  }
+
+  /**
+   * Find promotion code by specific criteria type
+   */
+  public static findByCode(code: string, options: FindOptions<PromotionCode> = {}) {
+    return this.findOne({
+      where: { code },
+      ...options,
+    });
+  }
+
+  public static findByNftAddress(nftAddress: string, options: FindOptions<PromotionCode> = {}) {
+    return this.findOne({
+      where: {
+        verification_type: 'nft',
+        'nft_config.addresses': {
+          [Op.contains]: [nftAddress],
+        },
+      } as any,
+      ...options,
+    });
+  }
+
+  public static findByVcRole(vcRole: string, options: FindOptions<PromotionCode> = {}) {
+    return this.findOne({
+      where: {
+        verification_type: 'vc',
+        'vc_config.roles': {
+          [Op.contains]: [vcRole],
+        },
+      } as any,
+      ...options,
+    });
+  }
+
+  public static findByUserDid(userDid: string, options: FindOptions<PromotionCode> = {}) {
+    return this.findOne({
+      where: {
+        verification_type: 'user_restricted',
+        customer_dids: {
+          [Op.contains]: [userDid],
+        },
+      } as any,
+      ...options,
+    });
+  }
+
+  /**
+   * Check if promotion code is being used
+   */
+  public async isUsed() {
+    const { Discount } = this.sequelize.models;
+    const discountCount = await Discount!.count({
+      where: { promotion_code_id: this.id },
+    });
+
+    if (discountCount > 0) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if promotion code is valid for use
+   */
+  public isValid() {
+    if (!this.active) {
+      return { valid: false, reason: 'Promotion code is inactive' };
+    }
+
+    if (this.expires_at && Math.floor(Date.now() / 1000) > this.expires_at) {
+      return { valid: false, reason: 'Promotion code has expired' };
+    }
+
+    if (this.max_redemptions && (this.times_redeemed ?? 0) >= this.max_redemptions) {
+      return { valid: false, reason: 'Promotion code has reached maximum redemptions' };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Insert promotion code with formatting
+   */
+  public static insert(promotionCode: Partial<TPromotionCode>) {
+    const formattedData = this.formatBeforeSave({
+      active: true,
+      times_redeemed: 0,
+      metadata: {},
+      ...promotionCode,
+    });
+    return this.create(formattedData as any);
+  }
+
+  /**
+   * Format restrictions currency options for storage - convert unit amounts to token amounts
+   */
+  public static formatRestrictionsCurrencyOptions(
+    restrictions: Restrictions | undefined,
+    currencies: TPaymentCurrency[]
+  ): Restrictions | undefined {
+    if (!restrictions || !restrictions.currency_options) {
+      return restrictions;
+    }
+
+    const formatted: Record<string, { minimum_amount: string }> = {};
+
+    if (restrictions.minimum_amount && restrictions.minimum_amount_currency) {
+      const currency = currencies.find((c) => c.id === restrictions.minimum_amount_currency);
+      if (!currency) {
+        throw new Error(`currency ${restrictions.minimum_amount_currency} not found or inactive`);
+      }
+      restrictions.minimum_amount = fromTokenToUnit(
+        trimDecimals(restrictions.minimum_amount, currency.decimal),
+        currency.decimal
+      ).toString();
+    }
+
+    for (const [currencyId, optionData] of Object.entries(restrictions.currency_options)) {
+      const currency = currencies.find((c) => c.id === currencyId);
+      if (!currency) {
+        throw new Error(`currency ${currencyId} used in promotion code not found or inactive`);
+      }
+
+      formatted[currencyId] = {
+        minimum_amount: fromTokenToUnit(
+          trimDecimals(optionData.minimum_amount || '0', currency.decimal),
+          currency.decimal
+        ).toString(),
+      };
+
+      if (restrictions.minimum_amount && !restrictions.currency_options[currencyId]) {
+        restrictions.currency_options[currencyId] = {
+          minimum_amount: restrictions.minimum_amount,
+        };
+      }
+    }
+
+    // Return with the correct storage format (string values)
+    return {
+      ...restrictions,
+      currency_options: formatted,
+    } as any;
+  }
 }
 
 export type TPromotionCode = InferAttributes<PromotionCode>;

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

@@ -138,7 +138,9 @@ export type SimpleCustomField = {
 
 export type DiscountAmount = {
   amount: number;
-  discount: string;
+  discount?: string;
+  promotion_code?: string;
+  coupon?: string;
 };
 
 export type CustomerAddress = {
@@ -788,3 +790,30 @@ export type RechargeConfig = {
     max_recharge_amount?: number;
   };
 };
+
+export type NFTConfig = {
+  addresses?: string[];
+  tags?: string[];
+  trusted_issuers?: string[];
+  trusted_parents?: string[];
+  min_balance?: number;
+};
+
+export type VCConfig = {
+  roles?: string[];
+  trusted_issuers?: string[];
+};
+
+export type VerificationType = 'code' | 'nft' | 'vc' | 'user_restricted';
+
+export type Restrictions = {
+  currency_options?: Record<
+    string,
+    {
+      minimum_amount: string;
+    }
+  >;
+  first_time_transaction?: boolean;
+  minimum_amount?: string;
+  minimum_amount_currency?: string;
+};

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

@@ -3,8 +3,6 @@ import {
   getBillingThreshold,
   getCheckoutAmount,
   getCheckoutMode,
-  getPriceCurrencyOptions,
-  getPriceUintAmountByCurrency,
   getRecurringPeriod,
   getSubscriptionCreateSetup,
   getCheckoutSessionSubscriptionIds,
@@ -15,6 +13,7 @@ import {
   createPaymentBeneficiaries,
   getSubscriptionLineItems,
 } from '../../src/libs/session';
+import { getPriceCurrencyOptions, getPriceUintAmountByCurrency } from '../../src/libs/price';
 import type { TLineItemExpanded } from '../../src/store/models';
 import type { PaymentBeneficiary } from '../../src/store/models/types';
 import { SubscriptionItem } from '../../src/store/models';
@@ -177,8 +176,8 @@ describe('getBillingThreshold', () => {
   });
 });
 
-describe('getCheckoutAmount', () => {
-  it('should calculate the total amount correctly for recurring items', () => {
+describe('await getCheckoutAmount', () => {
+  it('should calculate the total amount correctly for recurring items', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '10' },
@@ -190,21 +189,21 @@ describe('getCheckoutAmount', () => {
       },
     ];
     const currencyId = 'usd';
-    const result = getCheckoutAmount(items as TLineItemExpanded[], currencyId);
+    const result = await getCheckoutAmount(items as TLineItemExpanded[], currencyId);
     expect(result.total).toBe('20'); // Update the expected value based on your calculation
   });
 
-  it('should calculate the total amount correctly for non-recurring items', () => {
+  it('should calculate the total amount correctly for non-recurring items', async () => {
     const items = [
       { price: { type: 'one_time', currency_id: 'usd', unit_amount: '10' }, quantity: 2 },
       { price: { type: 'one_time', currency_id: 'usd', unit_amount: '20' }, quantity: 3 },
     ];
     const currencyId = 'usd';
-    const result = getCheckoutAmount(items as TLineItemExpanded[], currencyId);
+    const result = await getCheckoutAmount(items as TLineItemExpanded[], currencyId);
     expect(result.total).toBe('80');
   });
 
-  it('should calculate the total amount correctly when trialing is true', () => {
+  it('should calculate the total amount correctly when trialing is true', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '10' },
@@ -216,11 +215,11 @@ describe('getCheckoutAmount', () => {
       },
     ];
     const currencyId = 'usd';
-    const result = getCheckoutAmount(items as TLineItemExpanded[], currencyId, true);
+    const result = await getCheckoutAmount(items as TLineItemExpanded[], currencyId, true);
     expect(result.total).toBe('0');
   });
 
-  it('should throw when when custom_unit_amount is provided with other item', () => {
+  it('should throw when when custom_unit_amount is provided with other item', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '10' },
@@ -237,12 +236,12 @@ describe('getCheckoutAmount', () => {
       },
     ];
     const currencyId = 'usd';
-    expect(() => getCheckoutAmount(items as any[], currencyId)).toThrow(
+    await expect(getCheckoutAmount(items as any[], currencyId)).rejects.toThrow(
       'Multiple items with custom unit amount are not supported'
     );
   });
 
-  it('should calculate the total amount correctly when custom_unit_amount.preset is provided', () => {
+  it('should calculate the total amount correctly when custom_unit_amount.preset is provided', async () => {
     const items = [
       {
         price: {
@@ -255,11 +254,11 @@ describe('getCheckoutAmount', () => {
       },
     ];
     const currencyId = 'usd';
-    const result = getCheckoutAmount(items as TLineItemExpanded[], currencyId);
+    const result = await getCheckoutAmount(items as TLineItemExpanded[], currencyId);
     expect(result.total).toBe('10');
   });
 
-  it('should calculate the total amount correctly when custom_unit_amount.presets is provided', () => {
+  it('should calculate the total amount correctly when custom_unit_amount.presets is provided', async () => {
     const items = [
       {
         price: {
@@ -272,7 +271,7 @@ describe('getCheckoutAmount', () => {
       },
     ];
     const currencyId = 'usd';
-    const result = getCheckoutAmount(items as TLineItemExpanded[], currencyId);
+    const result = await getCheckoutAmount(items as TLineItemExpanded[], currencyId);
     expect(result.total).toBe('20');
   });
 });
@@ -531,35 +530,45 @@ describe('mergeSubscriptionDataFromLineItems', () => {
 });
 
 describe('getFastCheckoutAmount', () => {
-  it('should return total amount for payment mode', () => {
+  it('should return total amount for payment mode', async () => {
     const items = [{ price: { type: 'one_time', currency_id: 'usd', unit_amount: '100' }, quantity: 1 }];
-    const result = getFastCheckoutAmount(items as TLineItemExpanded[], 'payment', 'usd');
+    const result = await getFastCheckoutAmount({
+      items: items as TLineItemExpanded[],
+      mode: 'payment',
+      currencyId: 'usd',
+    });
     expect(result).toBe('100');
   });
 
-  it('should return renew amount for setup mode', () => {
+  it('should return renew amount for setup mode', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '100' },
         quantity: 1,
       },
     ];
-    const result = getFastCheckoutAmount(items as any, 'setup', 'usd');
+    const result = await getFastCheckoutAmount({ items: items as any, mode: 'setup', currencyId: 'usd' });
     expect(result).toBe('100');
   });
 
-  it('should multiply renew amount by minimumCycle for setup mode', () => {
+  it('should multiply renew amount by minimumCycle for setup mode', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '100' },
         quantity: 1,
       },
     ];
-    const result = getFastCheckoutAmount(items as any, 'setup', 'usd', false, 3);
+    const result = await getFastCheckoutAmount({
+      items: items as any,
+      mode: 'setup',
+      currencyId: 'usd',
+      trialing: false,
+      minimumCycle: 3,
+    });
     expect(result).toBe('300');
   });
 
-  it('should return total + renew*(minimumCycle-1) for subscription mode', () => {
+  it('should return total + renew*(minimumCycle-1) for subscription mode', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '100' },
@@ -567,11 +576,17 @@ describe('getFastCheckoutAmount', () => {
       },
       { price: { type: 'one_time', currency_id: 'usd', unit_amount: '50' }, quantity: 1 },
     ];
-    const result = getFastCheckoutAmount(items as any, 'subscription', 'usd', false, 3);
+    const result = await getFastCheckoutAmount({
+      items: items as any,
+      mode: 'subscription',
+      currencyId: 'usd',
+      trialing: false,
+      minimumCycle: 3,
+    });
     expect(result).toBe('350');
   });
 
-  it('should return total + renew*minimumCycle for subscription mode when trialing', () => {
+  it('should return total + renew*minimumCycle for subscription mode when trialing', async () => {
     const items = [
       {
         price: { type: 'recurring', recurring: { usage_type: 'licensed' }, currency_id: 'usd', unit_amount: '100' },
@@ -579,13 +594,19 @@ describe('getFastCheckoutAmount', () => {
       },
       { price: { type: 'one_time', currency_id: 'usd', unit_amount: '50' }, quantity: 1 },
     ];
-    const result = getFastCheckoutAmount(items as any, 'subscription', 'usd', true, 3);
+    const result = await getFastCheckoutAmount({
+      items: items as any,
+      mode: 'subscription',
+      currencyId: 'usd',
+      trialing: true,
+      minimumCycle: 3,
+    });
     expect(result).toBe('350'); // 50 (total, since recurring is 0 during trial) + 100 (renew) * 3
   });
 
-  it('should return 0 for unknown mode', () => {
+  it('should return 0 for unknown mode', async () => {
     const items = [{ price: { type: 'one_time', currency_id: 'usd', unit_amount: '100' }, quantity: 1 }];
-    const result = getFastCheckoutAmount(items as any, 'unknown', 'usd');
+    const result = await getFastCheckoutAmount({ items: items as any, mode: 'unknown', currencyId: 'usd' });
     expect(result).toBe('0');
   });
 });

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.20.11
+version: 1.20.13
 logo: logo.png
 files:
   - dist