payment-kit 1.20.20 → 1.20.22

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.22
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.20.20",
+  "version": "1.20.22",
   "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.22",
+    "@blocklet/payment-react": "1.20.22",
+    "@blocklet/payment-vendor": "1.20.22",
     "@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.22",
     "@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": "a0a691de0cd6e47efbc0e4de01d200bb9193c435"
 }

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 = `

package/src/components/invoice-pdf/template.tsx

@@ -120,7 +120,7 @@ export function InvoiceTemplate({ data, t }: InvoicePDFProps) {
               </span>
             </div>
             <div style={composeStyles('w-15 p-4-8 pb-15')}>
-              <span style={composeStyles(`${itemDiscountAmount > 0 ? 'green' : 'dark'} right`)}>
+              <span style={composeStyles('dark right')}>
                 {itemDiscountAmount > 0
                   ? `-${formatAmount(itemDiscountAmount.toString(), data.paymentCurrency.decimal)} ${
                       data.paymentCurrency.symbol
@@ -138,24 +138,56 @@ export function InvoiceTemplate({ data, t }: InvoicePDFProps) {
       })}
 
       {/* Summary */}
-      <div style={composeStyles('flex')}>
-        <div style={composeStyles('w-60 mt-20')} />
-        <div style={composeStyles('w-40 mt-20')}>
-          {summary.map((line) => (
-            <div style={composeStyles('flex')} key={line.key}>
-              <div style={composeStyles('w-60 p-5')}>
+      <div
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          alignItems: 'flex-end',
+          float: 'right',
+          paddingRight: '8px',
+          marginTop: '8px',
+          width: '100%',
+          minWidth: '280px',
+        }}>
+        {summary.map((line) => {
+          const isTotal = line.key === 'Total' || line.key === 'common.total' || line.key === 'payment.total';
+          const showDivider = isTotal;
+
+          return (
+            <div key={line.key} style={{ width: '100%' }}>
+              {showDivider && (
+                <div
+                  style={{
+                    borderTop: '1px solid #e3e3e3',
+                    width: '100%',
+                    marginBottom: '8px',
+                    marginTop: '4px',
+                  }}
+                />
+              )}
+              <div
+                style={{
+                  display: 'flex',
+                  justifyContent: 'flex-end',
+                  width: '100%',
+                  padding: '4px 0',
+                  paddingRight: '8%',
+                  gap: '20px',
+                }}>
                 <span style={composeStyles('bold')}>
                   {line.key.startsWith('common.') || line.key.startsWith('payment.') ? t(line.key) : line.key}
                 </span>
-              </div>
-              <div style={composeStyles('w-40 p-5')}>
-                <span style={composeStyles('right bold dark')}>
+                <span
+                  style={{
+                    ...composeStyles('bold dark text-right'),
+                    minWidth: '80px',
+                  }}>
                   {line.value} {data.paymentCurrency.symbol}
                 </span>
               </div>
             </div>
-          ))}
-        </div>
+          );
+        })}
       </div>
     </div>
   );

package/src/components/metadata/list.tsx

@@ -22,6 +22,7 @@ export default function MetadataList({
           variant="subtitle1"
           sx={{
             color: 'text.primary',
+            fontWeight: 500,
           }}>
           {t('common.metadata.empty')}
         </Typography>

package/src/components/subscription/metrics.tsx

@@ -13,6 +13,7 @@ import SubscriptionStatus from './status';
 type Props = {
   subscription: TSubscriptionExpanded;
   showBalance?: boolean;
+  mode?: 'portal' | 'admin';
 };
 
 const fetchUpcoming = (id: string): Promise<{ amount: string }> => {
@@ -35,7 +36,7 @@ const fetchCreditBalance = ({
     .then((res) => res.data);
 };
 
-export default function SubscriptionMetrics({ subscription, showBalance = true }: Props) {
+export default function SubscriptionMetrics({ subscription, showBalance = true, mode = 'portal' }: Props) {
   const { t } = useLocaleContext();
   const isCredit = subscription.paymentCurrency?.type === 'credit';
   const { data: upcoming, loading: upcomingLoading } = useRequest(() => fetchUpcoming(subscription.id));
@@ -59,6 +60,7 @@ export default function SubscriptionMetrics({ subscription, showBalance = true }
   );
 
   const supportShowBalance = showBalance && ['arcblock', 'ethereum', 'base'].includes(subscription.paymentMethod.type);
+
   // let scheduleToCancelTime = 0;
   // if (['active', 'trialing', 'past_due'].includes(subscription.status) && subscription.cancel_at) {
   //   scheduleToCancelTime = subscription.cancel_at * 1000;
@@ -69,7 +71,7 @@ export default function SubscriptionMetrics({ subscription, showBalance = true }
   const isInsufficientBalance = new BN(payerValue?.token || '0').lt(new BN(upcoming?.amount || '0'));
 
   const handleRecharge = () => {
-    if (isCredit) {
+    if (isCredit || mode !== 'portal') {
       return;
     }
     navigate(`/customer/subscription/${subscription.id}/recharge`);
@@ -80,7 +82,9 @@ export default function SubscriptionMetrics({ subscription, showBalance = true }
       return <CircularProgress size={16} />;
     }
 
-    if (isInsufficientBalance && !isCredit) {
+    const canRecharge = mode === 'portal';
+
+    if (isInsufficientBalance && !isCredit && canRecharge) {
       return (
         <Button
           component="a"