payment-kit 1.20.20 → 1.20.21

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

@@ -0,0 +1,219 @@
+import {
+  validCoupon,
+  validPromotionCode,
+  calculateDiscountAmount,
+  checkPromotionCodeEligibility,
+  getValidDiscountsForSubscriptionBilling,
+  expandLineItemsWithCouponInfo,
+  expandDiscountsWithDetails,
+  createDiscountRecordsForCheckout,
+  updateSubscriptionDiscountReferences,
+} from '../../src/libs/discount/coupon';
+import { Coupon, Customer, Discount, PromotionCode, Subscription, PaymentCurrency } from '../../src/store/models';
+
+jest.mock('../../src/libs/logger', () => ({
+  __esModule: true,
+  default: { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() },
+}));
+
+jest.mock('../../src/libs/event', () => ({ emitAsync: jest.fn() }));
+
+describe('libs/discount/coupon.ts', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  describe('validCoupon', () => {
+    it('rejects invalid or expired or fully redeemed coupon', () => {
+      expect(validCoupon({ valid: false } as any).valid).toBe(false);
+      const expired = Math.floor(Date.now() / 1000) - 10;
+      expect(validCoupon({ valid: true, redeem_by: expired } as any).valid).toBe(false);
+      expect(validCoupon({ valid: true, max_redemptions: 1, times_redeemed: 1 } as any).valid).toBe(false);
+    });
+
+    it('enforces applies_to products if provided', () => {
+      const coupon = { valid: true, applies_to: { products: ['p1'] } } as any;
+      const lineItems = [{ price: { product_id: 'p2' } }] as any;
+      const res = validCoupon(coupon, lineItems);
+      expect(res.valid).toBe(false);
+    });
+
+    it('passes when valid and applicable', () => {
+      const coupon = { valid: true } as any;
+      expect(validCoupon(coupon).valid).toBe(true);
+    });
+  });
+
+  describe('validPromotionCode', () => {
+    it('rejects inactive/expired/max redeemed', async () => {
+      const now = Math.floor(Date.now() / 1000);
+      await expect(validPromotionCode({ active: false } as any, {})).resolves.toEqual({
+        valid: false,
+        reason: expect.any(String),
+      });
+      await expect(validPromotionCode({ active: true, expires_at: now - 30 } as any, {})).resolves.toEqual({
+        valid: false,
+        reason: expect.any(String),
+      });
+      await expect(
+        validPromotionCode({ active: true, max_redemptions: 1, times_redeemed: 1 } as any, {})
+      ).resolves.toEqual({ valid: false, reason: expect.any(String) });
+    });
+
+    it('checks user restriction and first time transaction', async () => {
+      jest.spyOn(Customer, 'findByPkOrDid').mockResolvedValue({ did: 'did:user:1' } as any);
+      const pc: any = { active: true, verification_type: 'user_restricted', customer_dids: ['did:user:1'] };
+      await expect(validPromotionCode(pc, { customerId: 'c1' })).resolves.toEqual({ valid: true });
+
+      jest.spyOn(Discount, 'count').mockResolvedValue(1 as any);
+      const pc2: any = {
+        active: true,
+        restrictions: { first_time_transaction: true },
+      };
+      await expect(validPromotionCode(pc2, { customerId: 'c1' })).resolves.toEqual({
+        valid: false,
+        reason: expect.any(String),
+      });
+    });
+
+    it('checks minimum amount by currency', async () => {
+      jest.spyOn(PaymentCurrency, 'findByPk').mockResolvedValue({ id: 'usd', decimal: 2, symbol: 'USD' } as any);
+      const pc: any = {
+        active: true,
+        restrictions: { minimum_amount: '200', minimum_amount_currency: 'usd' },
+      };
+      await expect(validPromotionCode(pc, { amount: '100', currencyId: 'usd' })).resolves.toEqual({
+        valid: false,
+        reason: expect.stringContaining('minimum purchase'),
+      });
+    });
+  });
+
+  describe('calculateDiscountAmount', () => {
+    it('handles percent_off and amount_off with cap', () => {
+      expect(
+        calculateDiscountAmount({ percent_off: 25 } as any, '400', { id: 'usd', decimal: 2, symbol: 'USD' } as any)
+      ).toBe('100');
+
+      expect(
+        calculateDiscountAmount({ amount_off: '150', currency_id: 'usd' } as any, '100', {
+          id: 'usd',
+          decimal: 2,
+          symbol: 'USD',
+        } as any)
+      ).toBe('100');
+    });
+  });
+
+  describe('checkPromotionCodeEligibility', () => {
+    it('validates promotion and coupon together', async () => {
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({ valid: true } as any);
+      jest.spyOn(Customer, 'findByPkOrDid').mockResolvedValue({ did: 'did:user:1' } as any);
+      jest.spyOn(PaymentCurrency, 'findByPk').mockResolvedValue({ id: 'usd', decimal: 2, symbol: 'USD' } as any);
+      jest.spyOn(Discount, 'count').mockResolvedValue(0 as any);
+      const couponModule = await import('../../src/libs/discount/coupon');
+      jest.spyOn(couponModule, 'validCoupon').mockReturnValue({ valid: true } as any);
+      const result = await checkPromotionCodeEligibility({
+        promotionCode: { active: true } as any,
+        couponId: 'c1',
+        customerId: 'u1',
+        amount: '100',
+        currencyId: 'usd',
+      });
+      expect(result.eligible).toBe(true);
+    });
+  });
+
+  describe('validateDiscountForBilling & getValidDiscountsForSubscriptionBilling', () => {
+    it('filters discounts by duration logic', async () => {
+      const now = Math.floor(Date.now() / 1000);
+      jest.spyOn(Discount, 'findAll').mockResolvedValue([
+        { id: 'd_once', coupon_id: 'c_once' },
+        { id: 'd_repired', coupon_id: 'c_repired', end: now - 1 },
+        { id: 'd_forever', coupon_id: 'c_forever' },
+      ] as any);
+
+      jest.spyOn(Coupon, 'findByPk').mockImplementation((id) => {
+        if (id === 'c_once') return { duration: 'once' } as any;
+        if (id === 'c_repired') return { duration: 'repeating' } as any;
+        return { duration: 'forever' } as any;
+      });
+
+      const { validDiscounts, expiredDiscounts } = await getValidDiscountsForSubscriptionBilling({
+        subscriptionId: 'sub_1',
+        customerId: 'u1',
+      });
+
+      expect(validDiscounts.map((d) => d.id)).toEqual(['d_forever']);
+      expect(expiredDiscounts.map((d) => d.id).sort()).toEqual(['d_once', 'd_repired'].sort());
+    });
+  });
+
+  describe('expandLineItemsWithCouponInfo & expandDiscountsWithDetails', () => {
+    it('expands discount info on line items', async () => {
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({
+        id: 'c1',
+        name: 'c',
+        amount_off: '10',
+        percent_off: 0,
+        currency_id: 'usd',
+        duration: 'once',
+      } as any);
+      jest.spyOn(PromotionCode, 'findByPk').mockResolvedValue({ id: 'pc1', code: 'CODE1' } as any);
+
+      const items = [{ id: 'i1', discount_amounts: [{ amount: '10', coupon: 'c1' }] }] as any;
+
+      const res = await expandLineItemsWithCouponInfo(items, [{ coupon: 'c1', promotion_code: 'pc1' }], 'usd');
+      expect(res[0]?.discount_amounts[0]?.coupon.id).toBe('c1');
+      expect(res[0]?.discount_amounts[0]?.promotion_code.id).toBe('pc1');
+    });
+
+    it('expands discounts array with details', async () => {
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({ id: 'c1', name: 'c' } as any);
+      jest.spyOn(PromotionCode, 'findByPk').mockResolvedValue({ id: 'pc1', code: 'CODE1' } as any);
+      const res = await expandDiscountsWithDetails([{ coupon: 'c1', promotion_code: 'pc1' }]);
+      expect(res[0].coupon_details.id).toBe('c1');
+      expect(res[0].promotion_code_details.id).toBe('pc1');
+    });
+  });
+
+  describe('createDiscountRecordsForCheckout & updateSubscriptionDiscountReferences', () => {
+    it('creates/updates records and usage counts per discount config', async () => {
+      const checkoutSession: any = {
+        id: 'cs_1',
+        discounts: [{ coupon: 'c1', promotion_code: 'pc1', discount_amount: '50' }],
+      };
+
+      jest.spyOn(Discount, 'findAll').mockResolvedValue([] as any);
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({ id: 'c1', livemode: false, duration: 'once' } as any);
+      jest.spyOn(PromotionCode, 'findByPk').mockResolvedValue({ id: 'pc1', verification_type: 'none' } as any);
+      jest
+        .spyOn(Discount, 'create')
+        .mockImplementation(
+          (data: any) => Promise.resolve({ id: `d_${Date.now()}`, update: jest.fn(), ...data }) as any
+        );
+
+      // Stubs for usage update path
+      jest.spyOn(Coupon.prototype as any, 'update').mockResolvedValue(undefined);
+      jest.spyOn(PromotionCode.prototype as any, 'update').mockResolvedValue(undefined);
+
+      const { discountRecords, subscriptionsUpdated } = await createDiscountRecordsForCheckout({
+        checkoutSession,
+        customerId: 'u1',
+        subscriptionIds: ['sub_1'],
+      });
+
+      expect(discountRecords.length).toBeGreaterThan(0);
+      expect(subscriptionsUpdated).toEqual(['sub_1']);
+
+      // updateSubscriptionDiscountReferences
+      jest.spyOn(Subscription, 'update').mockResolvedValue([1] as any);
+      const { updatedSubscriptions } = await updateSubscriptionDiscountReferences({
+        discountRecords,
+        subscriptionsUpdated,
+      });
+      expect(updatedSubscriptions).toEqual(['sub_1']);
+    });
+  });
+});

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

@@ -0,0 +1,250 @@
+import {
+  applyDiscountsToLineItems,
+  applySubscriptionDiscount,
+  rollbackDiscountUsageForCheckoutSession,
+} from '../../src/libs/discount/discount';
+import { Coupon, Discount, CheckoutSession } from '../../src/store/models';
+
+// Mock logger and event emitter to keep test output clean
+jest.mock('../../src/libs/logger', () => ({
+  __esModule: true,
+  default: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/libs/event', () => ({
+  emitAsync: jest.fn(),
+}));
+
+// Mock price util so we can control unit amounts per item
+jest.mock('../../src/libs/price', () => ({
+  getPriceUintAmountByCurrency: (price: any, currencyId: string) => {
+    if (!price) return '0';
+    if (price.unit_amount_map && price.unit_amount_map[currencyId]) return String(price.unit_amount_map[currencyId]);
+    if (price.unit_amount) return String(price.unit_amount);
+    if (Array.isArray(price.currency_options)) {
+      const opt = price.currency_options.find((c: any) => c.currency_id === currencyId);
+      return String(opt?.unit_amount || '0');
+    }
+    return '0';
+  },
+}));
+
+describe('libs/discount/discount.ts', () => {
+  const currency = { id: 'usd', decimal: 2, symbol: 'USD' } as any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  describe('applyDiscountsToLineItems - percent_off over eligible items', () => {
+    it('applies percentage discount only to eligible products and returns per-item breakdown', async () => {
+      const lineItems: any[] = [
+        {
+          id: 'li_1',
+          quantity: 1,
+          price: { product_id: 'p1', unit_amount_map: { usd: '100' } },
+        },
+        {
+          id: 'li_2',
+          quantity: 3,
+          price: { product_id: 'p2', unit_amount_map: { usd: '100' } }, // amount 300
+        },
+        {
+          id: 'li_3',
+          quantity: 2,
+          price: { product_id: 'p3', unit_amount_map: { usd: '50' } }, // ineligible
+        },
+      ];
+
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({
+        id: 'c1',
+        percent_off: 50,
+        amount_off: null,
+        applies_to: { products: ['p1', 'p2'] },
+        valid: true,
+      } as any);
+
+      // Force coupon validation to pass
+      const couponModule = await import('../../src/libs/discount/coupon');
+      jest.spyOn(couponModule, 'validCoupon').mockReturnValue({ valid: true } as any);
+
+      const result = await applyDiscountsToLineItems({
+        lineItems,
+        couponId: 'c1',
+        customerId: 'cust_1',
+        currency,
+      });
+
+      const { enhancedLineItems, discountSummary } = result;
+      // li_1 amount=100 -> 50% => 50; li_2 amount=300 -> 150; li_3 ineligible
+      const li1 = enhancedLineItems.find((x: any) => x.id === 'li_1');
+      const li2 = enhancedLineItems.find((x: any) => x.id === 'li_2');
+      const li3 = enhancedLineItems.find((x: any) => x.id === 'li_3');
+
+      expect(li1).toBeDefined();
+      expect(li2).toBeDefined();
+      expect(li3).toBeDefined();
+      expect((li1 as any).discountable).toBe(true);
+      expect((li1 as any).discount_amounts[0].amount).toBe('50');
+      expect((li2 as any).discountable).toBe(true);
+      expect((li2 as any).discount_amounts[0].amount).toBe('150');
+      expect((li3 as any).discountable).toBe(false);
+
+      expect(discountSummary.appliedCoupon).toBe('c1');
+      expect(discountSummary.totalDiscountAmount).toBe('200');
+      // base total = 100 + 300 + 100 = 500; final = 300
+      expect(discountSummary.finalTotal).toBe('300');
+      expect(result.notValidReason).toBeUndefined();
+    });
+  });
+
+  describe('applyDiscountsToLineItems - amount_off distributed proportionally', () => {
+    it('distributes fixed amount discount proportionally among eligible items', async () => {
+      const lineItems: any[] = [
+        { id: 'a', quantity: 1, price: { product_id: 'pa', unit_amount_map: { usd: '100' } } },
+        { id: 'b', quantity: 3, price: { product_id: 'pb', unit_amount_map: { usd: '100' } } }, // 300
+      ];
+
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({
+        id: 'c2',
+        percent_off: 0,
+        amount_off: '150',
+        currency_id: 'usd',
+        applies_to: { products: [] },
+        valid: true,
+      } as any);
+
+      const couponModule = await import('../../src/libs/discount/coupon');
+      jest.spyOn(couponModule, 'validCoupon').mockReturnValue({ valid: true } as any);
+
+      const { enhancedLineItems, discountSummary } = await applyDiscountsToLineItems({
+        lineItems,
+        couponId: 'c2',
+        customerId: 'cust_1',
+        currency,
+      });
+
+      // Total eligible = 400; adjustedDiscount=150
+      // a: 100/400 * 150 = 37; b: 300/400 * 150 = 112 (integer division)
+      const a = enhancedLineItems.find((x: any) => x.id === 'a');
+      const b = enhancedLineItems.find((x: any) => x.id === 'b');
+      expect(a).toBeDefined();
+      expect(b).toBeDefined();
+      expect((a as any).discount_amounts[0].amount).toBe('37');
+      expect((b as any).discount_amounts[0].amount).toBe('112');
+      expect(discountSummary.totalDiscountAmount).toBe('150');
+      expect(discountSummary.finalTotal).toBe('250');
+    });
+  });
+
+  describe('applyDiscountsToLineItems - invalid or missing coupon', () => {
+    it('returns not valid when coupon not found', async () => {
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue(null as any);
+      const { discountSummary, notValidReason } = await applyDiscountsToLineItems({
+        lineItems: [{ id: 'x', quantity: 1, price: { product_id: 'p1', unit_amount_map: { usd: '100' } } }] as any,
+        couponId: 'missing',
+        customerId: 'cust_1',
+        currency,
+      });
+      expect(discountSummary.totalDiscountAmount).toBe('0');
+      expect(notValidReason).toBe('Coupon not found');
+    });
+
+    it('returns not valid when validation fails', async () => {
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({ id: 'c3', valid: false } as any);
+      const couponModule = await import('../../src/libs/discount/coupon');
+      jest.spyOn(couponModule, 'validCoupon').mockReturnValue({ valid: false, reason: 'invalid' } as any);
+
+      const res = await applyDiscountsToLineItems({
+        lineItems: [{ id: 'x', quantity: 1, price: { product_id: 'p1', unit_amount_map: { usd: '100' } } }] as any,
+        couponId: 'c3',
+        customerId: 'cust_1',
+        currency,
+      });
+      expect(res.discountSummary.totalDiscountAmount).toBe('0');
+      expect(res.notValidReason).toBe('invalid');
+    });
+  });
+
+  describe('applySubscriptionDiscount', () => {
+    it('returns computed discount when coupon exists', async () => {
+      const items: any[] = [{ id: 'a', quantity: 2, price: { product_id: 'pa', unit_amount_map: { usd: '50' } } }];
+
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue({
+        id: 'c4',
+        percent_off: 20,
+        applies_to: { products: [] },
+        valid: true,
+      } as any);
+
+      const result = await applySubscriptionDiscount({
+        lineItems: items as any,
+        discount: { coupon_id: 'c4', id: 'd1' } as any,
+        currency,
+      });
+
+      expect(result.discountSummary.appliedCoupon).toBe('c4');
+      // amount = 2*50=100; 20% => 20; final 80
+      expect(result.discountSummary.totalDiscountAmount).toBe('20');
+      expect(result.discountSummary.finalTotal).toBe('80');
+    });
+
+    it('returns original items when coupon missing', async () => {
+      jest.spyOn(Coupon, 'findByPk').mockResolvedValue(null as any);
+      const items: any[] = [{ id: 'a', quantity: 1, price: { unit_amount_map: { usd: '100' } } }];
+      const res = await applySubscriptionDiscount({
+        lineItems: items as any,
+        discount: { coupon_id: 'missing', id: 'd2' } as any,
+        currency,
+      });
+      expect(res.discountSummary.totalDiscountAmount).toBe('0');
+      expect((res.enhancedLineItems[0] as any).discountable).toBe(false);
+      expect(res.discountSummary.finalTotal).toBe('100');
+    });
+  });
+
+  describe('rollbackDiscountUsageForCheckoutSession', () => {
+    it('rolls back confirmed discounts and destroys records', async () => {
+      jest.spyOn(CheckoutSession, 'findByPk').mockResolvedValue({ id: 'cs_1', status: 'open' } as any);
+
+      const coupon = { id: 'c1', times_redeemed: 2, update: jest.fn().mockResolvedValue(undefined) } as any;
+      const pc = { id: 'pc1', times_redeemed: 3, update: jest.fn().mockResolvedValue(undefined) } as any;
+
+      const discounts = [
+        { id: 'd1', confirmed: true, coupon, promotionCode: pc, destroy: jest.fn().mockResolvedValue(undefined) },
+        { id: 'd2', confirmed: true, coupon, promotionCode: pc, destroy: jest.fn().mockResolvedValue(undefined) },
+        { id: 'd3', confirmed: false, coupon, promotionCode: pc, destroy: jest.fn().mockResolvedValue(undefined) },
+      ] as any;
+
+      jest.spyOn(Discount, 'findAll').mockResolvedValue(discounts);
+
+      await rollbackDiscountUsageForCheckoutSession('cs_1');
+
+      // For unique coupon and promotion code, update should be called once each
+      expect(coupon.update).toHaveBeenCalledWith({ times_redeemed: 1, valid: true });
+      expect(pc.update).toHaveBeenCalledWith({ times_redeemed: 2, active: true });
+      // All discounts should be destroyed
+      discounts.forEach((d: any) => expect(d.destroy).toHaveBeenCalled());
+    });
+
+    it('early returns when session not found or completed', async () => {
+      const findByPkSpy = jest.spyOn(CheckoutSession, 'findByPk');
+      const discountFindAllSpy = jest.spyOn(Discount, 'findAll');
+
+      findByPkSpy.mockResolvedValueOnce(null as any);
+      await rollbackDiscountUsageForCheckoutSession('missing');
+
+      findByPkSpy.mockResolvedValueOnce({ id: 'cs_2', status: 'complete' } as any);
+      await rollbackDiscountUsageForCheckoutSession('cs_2');
+
+      // Should not query discounts in either case
+      expect(discountFindAllSpy).not.toHaveBeenCalled();
+    });
+  });
+});

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.20.20",
+  "version": "1.20.21",
   "scripts": {
     "dev": "blocklet dev --open",
     "lint": "tsc --noEmit && eslint src api/src --ext .mjs,.js,.jsx,.ts,.tsx",
@@ -52,13 +52,13 @@
     "@arcblock/jwt": "^1.25.3",
     "@arcblock/ux": "^3.1.41",
     "@arcblock/validator": "^1.25.3",
-    "@blocklet/did-space-js": "^1.1.26",
+    "@blocklet/did-space-js": "^1.1.27",
     "@blocklet/error": "^0.2.5",
     "@blocklet/js-sdk": "^1.16.52-beta-20250912-112002-e3499e9c",
     "@blocklet/logger": "^1.16.52-beta-20250912-112002-e3499e9c",
-    "@blocklet/payment-broker-client": "1.20.20",
-    "@blocklet/payment-react": "1.20.20",
-    "@blocklet/payment-vendor": "1.20.20",
+    "@blocklet/payment-broker-client": "1.20.21",
+    "@blocklet/payment-react": "1.20.21",
+    "@blocklet/payment-vendor": "1.20.21",
     "@blocklet/sdk": "^1.16.52-beta-20250912-112002-e3499e9c",
     "@blocklet/ui-react": "^3.1.41",
     "@blocklet/uploader": "^0.2.12",
@@ -128,7 +128,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.52-beta-20250912-112002-e3499e9c",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.20.20",
+    "@blocklet/payment-types": "1.20.21",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -175,5 +175,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "0aa636abf410af4ba08cf03fd4a15ae3beab115d"
+  "gitHead": "43b26f9e7373a99000f6a14762fdab860a562967"
 }

package/src/components/discount/discount-info.tsx

@@ -92,7 +92,6 @@ export default function DiscountInfo({ discountStats = null }: DiscountInfoProps
         bgcolor: 'grey.50',
         borderRadius: 1.5,
         p: 2.5,
-        my: 2,
         border: '1px solid',
         borderColor: 'divider',
       }}>

package/src/components/invoice/action.tsx

@@ -62,6 +62,16 @@ export default function InvoiceActions({ data, variant = 'compact', onChange, mo
           Toast.error(result.error);
         }
       }
+      if (state.action === 'retry-uncollectible') {
+        await api
+          .get('/api/invoices/retry-uncollectible', {
+            params: {
+              invoiceId: data.id,
+            },
+          })
+          .then((res) => res.data);
+        Toast.success(t('admin.invoice.retryUncollectible.success'));
+      }
       if (state.action === 'void') {
         await api.post(`/api/invoices/${data.id}/void`).then((res) => res.data);
         Toast.success(t('admin.invoice.void.success'));
@@ -89,6 +99,12 @@ export default function InvoiceActions({ data, variant = 'compact', onChange, mo
       disabled: data.status !== 'draft',
       divider: true,
     },
+    isAdmin &&
+      data.status === 'uncollectible' && {
+        label: t('admin.invoice.retryUncollectible.title'),
+        handler: () => setState({ action: 'retry-uncollectible' }),
+        color: 'primary',
+      },
     showReturnStake &&
       stakeResult &&
       stakeResult.value !== '0' && {
@@ -134,6 +150,16 @@ export default function InvoiceActions({ data, variant = 'compact', onChange, mo
   return (
     <ClickBoundary>
       <Actions variant={variant} actions={actions as any} onOpenCallback={fetchStakeResultAsync} />
+      {state.action === 'retry-uncollectible' && (
+        <ConfirmDialog
+          onConfirm={handleAction}
+          onCancel={() => setState({ action: '' })}
+          title={t('admin.invoice.retryUncollectible.title')}
+          message={t('admin.invoice.retryUncollectible.tip')}
+          loading={state.loading}
+          color="primary"
+        />
+      )}
       {state.action === 'return-stake' && (
         <ConfirmDialog
           onConfirm={handleAction}

package/src/components/invoice/table.tsx

@@ -210,7 +210,7 @@ export default function InvoiceTable({ invoice, simple = false, emptyNodeText =
 
   const columns = [
     {
-      label: t('common.description'),
+      label: t('admin.subscription.product'),
       name: 'product',
       options: {
         customBodyRenderLite: (_: string, index: number) => {
@@ -386,17 +386,10 @@ export default function InvoiceTable({ invoice, simple = false, emptyNodeText =
               xs: 1,
               md: 1,
             },
-            width: {
-              xs: '100%',
-              md: 'auto',
-            },
+            width: '100%',
             minWidth: {
               md: '280px',
             },
-            maxWidth: {
-              xs: '100%',
-              md: '400px',
-            },
           }}>
           {summary.map((line, index) => {
             const isTotal = line.key === 'common.total';

package/src/components/invoice-pdf/styles.ts

@@ -60,6 +60,7 @@ export const pdfStyles: InvoiceStyles = {
   'w-40': { width: '40%' },
   'w-48': { width: '48%' },
   'w-38': { width: '38%' },
+  'w-83': { width: '83%' },
   'w-17': { width: '17%' },
   'w-18': { width: '18%' },
   'w-15': { width: '15%' },
@@ -106,6 +107,7 @@ export const pdfStyles: InvoiceStyles = {
   },
   block: { display: 'block' },
   'ml-40': { marginLeft: '40px' },
+  'text-right': { textAlign: 'right' },
 };
 
 export const styles = `