payment-kit 1.15.20 → 1.15.22

package/api/src/routes/payment-links.ts

@@ -194,6 +194,7 @@ router.post('/', auth, async (req, res) => {
   try {
     const { error } = PaymentLinkCreateSchema.validate(req.body);
     if (error) {
+      logger.warn('Payment link create request invalid', { error: error.message, body: req.body });
       res.status(400).json({ error: `Payment link create request invalid: ${error.message}` });
       return;
     }
@@ -204,9 +205,10 @@ router.post('/', auth, async (req, res) => {
       currency_id: req.body.currency_id || req.currency.id,
       metadata: formatMetadata(req.body.metadata),
     });
+    logger.info('Payment link created successfully', { id: result.id, user: req.user?.did });
     res.json(result);
   } catch (err) {
-    logger.error('create payment link error', err);
+    logger.error('Create payment link error', { error: err.message, stack: err.stack, body: req.body });
     res.status(400).json({ error: err.message });
   }
 });
@@ -321,23 +323,33 @@ const PaymentLinkUpdateSchema = Joi.object({
 router.put('/:id', auth, async (req, res) => {
   const { error } = PaymentLinkUpdateSchema.validate(req.body);
   if (error) {
+    logger.warn('Payment link update request invalid', { error: error.message, id: req.params.id, body: req.body });
     return res.status(400).json({ error: `Payment link update request invalid: ${error.message}` });
   }
   const doc = await PaymentLink.findByPk(req.params.id);
 
   if (!doc) {
+    logger.warn('Payment link not found for update', { id: req.params.id });
     return res.status(404).json({ error: 'payment link not found' });
   }
   if (doc.active === false) {
+    logger.warn('Attempt to update archived payment link', { id: req.params.id });
     return res.status(403).json({ error: 'payment link archived' });
   }
-  // if (doc.locked) {
-  //   return res.status(403).json({ error: 'payment link locked' });
-  // }
 
-  await doc.update(formatBeforeSave(Object.assign({}, doc.dataValues, req.body)));
-
-  res.json(doc);
+  try {
+    await doc.update(formatBeforeSave(Object.assign({}, doc.dataValues, req.body)));
+    logger.info('Payment link updated successfully', { id: req.params.id, user: req.user?.did });
+    res.json(doc);
+  } catch (err) {
+    logger.error('Update payment link error', {
+      error: err.message,
+      stack: err.stack,
+      id: req.params.id,
+      body: req.body,
+    });
+    res.status(500).json({ error: 'Failed to update payment link' });
+  }
 });
 
 // archive
@@ -345,19 +357,23 @@ router.put('/:id/archive', auth, async (req, res) => {
   const doc = await PaymentLink.findByPk(req.params.id);
 
   if (!doc) {
+    logger.warn('Payment link not found for archiving', { id: req.params.id });
     return res.status(404).json({ error: 'payment link not found' });
   }
 
   if (doc.active === false) {
+    logger.warn('Attempt to archive already archived payment link', { id: req.params.id });
     return res.status(403).json({ error: 'payment link already archived' });
   }
 
-  // if (doc.locked) {
-  //   return res.status(403).json({ error: 'payment link locked' });
-  // }
-
-  await doc.update({ active: false });
-  return res.json(doc);
+  try {
+    await doc.update({ active: false });
+    logger.info('Payment link archived successfully', { id: req.params.id, user: req.user?.did });
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Archive payment link error', { error: err.message, stack: err.stack, id: req.params.id });
+    return res.status(500).json({ error: 'Failed to archive payment link' });
+  }
 });
 
 // delete
@@ -372,12 +388,14 @@ router.delete('/:id', auth, async (req, res) => {
     return res.status(403).json({ error: 'payment link archived' });
   }
 
-  // if (doc.locked) {
-  //   return res.status(403).json({ error: 'payment link locked' });
-  // }
-
-  await doc.destroy();
-  return res.json(doc);
+  try {
+    await doc.destroy();
+    logger.info('Payment link deleted successfully', { id: req.params.id, user: req.user?.did });
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Delete payment link error', { error: err.message, stack: err.stack, id: req.params.id });
+    return res.status(500).json({ error: 'Failed to delete payment link' });
+  }
 });
 
 router.post('/stash', auth, async (req, res) => {
@@ -393,12 +411,14 @@ router.post('/stash', auth, async (req, res) => {
     let doc = await PaymentLink.findByPk(raw.id);
     if (doc) {
       await doc.update({ ...formatBeforeSave(req.body), livemode: raw.livemode });
+      logger.info('Stashed payment link updated', { id: raw.id, user: req.user?.did });
     } else {
       doc = await PaymentLink.create(raw as PaymentLink);
+      logger.info('New stashed payment link created', { id: raw.id, user: req.user?.did });
     }
     res.json(doc);
   } catch (err) {
-    console.error(err);
+    logger.error('Stash payment link error', { error: err.message, stack: err.stack, body: req.body });
     res.status(500).json({ error: err.message });
   }
 });

package/api/src/routes/prices.ts

@@ -217,9 +217,10 @@ router.post('/', auth, async (req, res) => {
       quantity_sold: 0,
     });
 
+    logger.info(`Price created: ${result?.id}`, { priceId: result?.id, requestedBy: req.user?.did });
     res.json(result);
   } catch (err) {
-    console.error(err);
+    logger.error('Error creating price', { error: err.message, request: req.body });
     res.status(400).json({ error: err.message });
   }
 });
@@ -346,9 +347,14 @@ router.put('/:id', auth, async (req, res) => {
     }
   }
 
-  await doc.update(Price.formatBeforeSave(updates));
-
-  return res.json(await getExpandedPrice(req.params.id as string));
+  try {
+    await doc.update(Price.formatBeforeSave(updates));
+    logger.info(`Price updated: ${req.params.id}`, { priceId: req.params.id, updates, requestedBy: req.user?.did });
+    return res.json(await getExpandedPrice(req.params.id as string));
+  } catch (err) {
+    logger.error('Error updating price', { error: err.message, request: req.body });
+    return res.status(400).json({ error: err.message });
+  }
 });
 
 // archive
@@ -369,6 +375,7 @@ router.put('/:id/archive', auth, async (req, res) => {
 
   await price.update({ active: false });
 
+  logger.info(`Price archived: ${req.params.id}`, { priceId: req.params.id, requestedBy: req.user?.did });
   return res.json(await getExpandedPrice(req.params.id as string));
 });
 
@@ -431,6 +438,12 @@ router.put('/:id/inventory', auth, async (req, res) => {
       }
       await price.increment('quantity_sold', { by: req.body.quantity });
     }
+    logger.info(`Price inventory updated: ${req.params.id}`, {
+      priceId: req.params.id,
+      action: req.body.action,
+      quantity: req.body.quantity,
+      requestedBy: req.user?.did,
+    });
     return res.json(await getExpandedPrice(req.params.id as string));
   } catch (err) {
     logger.error('update price inventory error', err);

package/api/src/routes/products.ts

@@ -161,6 +161,12 @@ router.post('/', auth, async (req, res) => {
       currency_id: req.currency.id,
       metadata: formatMetadata(req.body.metadata),
     });
+    logger.info('Product and prices created', {
+      productId: result.id,
+      name: result.name,
+      priceCount: result.prices.length,
+      requestedBy: req.user?.did,
+    });
     res.json(result);
   } catch (err) {
     logger.error('create product error', err);
@@ -300,7 +306,11 @@ router.put('/:id', auth, async (req, res) => {
     updates.metadata = formatMetadata(updates.metadata);
   }
   await product.update(updates);
-
+  logger.info('Product updated', {
+    productId: product.id,
+    updatedFields: Object.keys(updates),
+    requestedBy: req.user?.did,
+  });
   return res.json(await Product.expand(req.params.id as string));
 });
 
@@ -346,7 +356,10 @@ router.delete('/:id', auth, async (req, res) => {
 
     await product.destroy();
     await Price.destroy({ where: { product_id: product.id } });
-
+    logger.info('Product and associated prices deleted', {
+      productId: product.id,
+      requestedBy: req.user?.did,
+    });
     return res.json(product);
   } catch (err) {
     logger.error('delete product error', err);
@@ -415,6 +428,12 @@ router.post('/batch-price-update', auth, async (req, res) => {
       })
     );
 
+    logger.info('Batch price update completed', {
+      updatedCount: updated.length,
+      dryRun,
+      factor,
+      requestedBy: req.user?.did,
+    });
     return res.json(updated);
   } catch (err) {
     logger.error('batch price update error', err);

package/api/src/routes/refunds.ts

@@ -169,10 +169,16 @@ router.post('/', authAdmin, async (req, res) => {
       ...req.params,
       ...req.body,
       result: item.toJSON(),
+      requestedBy: req.user?.did,
     });
     res.json(item);
   } catch (err) {
-    logger.error('create refund error', err);
+    logger.error('Create refund failed', {
+      error: err.message,
+      stack: err.stack,
+      requestBody: req.body,
+      requestedBy: req.user?.did,
+    });
     res.status(400).json({ error: err.message });
   }
 });
@@ -241,10 +247,21 @@ router.put('/:id', authAdmin, async (req, res) => {
     }
 
     await doc.update(raw);
+    logger.info('Refund updated', {
+      refundId: doc.id,
+      updatedFields: Object.keys(raw),
+      requestedBy: req.user?.did,
+    });
     res.json(doc);
   } catch (err) {
-    console.error(err);
-    res.json(null);
+    logger.error('Update refund failed', {
+      refundId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+      requestBody: req.body,
+      requestedBy: req.user?.did,
+    });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 

package/api/src/routes/subscription-items.ts

@@ -11,6 +11,7 @@ import { formatMetadata } from '../libs/util';
 import { Price, Product, Subscription, SubscriptionItem, UsageRecord } from '../store/models';
 import { forwardUsageRecordToStripe } from '../integrations/stripe/resource';
 import { usageRecordQueue } from '../queues/usage-record';
+import logger from '../libs/logger';
 
 const router = Router();
 const auth = authenticate<SubscriptionItem>({ component: true, roles: ['owner', 'admin'] });
@@ -42,6 +43,13 @@ router.post('/', auth, async (req, res) => {
   }
 
   const doc = await SubscriptionItem.create(raw as SubscriptionItem);
+  logger.info('SubscriptionItem created', {
+    id: doc.id,
+    subscriptionId: doc.subscription_id,
+    priceId: doc.price_id,
+    quantity: doc.quantity,
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -135,7 +143,12 @@ router.put('/:id', auth, async (req, res) => {
   }
 
   await doc.update(updates);
-
+  logger.info('SubscriptionItem updated', {
+    id: doc.id,
+    subscriptionId: doc.subscription_id,
+    updatedFields: Object.keys(updates),
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -156,7 +169,12 @@ router.delete('/:id', auth, async (req, res) => {
   }
 
   await doc.destroy();
-
+  logger.info('SubscriptionItem deleted', {
+    id: doc.id,
+    subscriptionId: doc.subscription_id,
+    clearUsage: req.body.clear_usage,
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -198,11 +216,23 @@ router.post('/:id/add-usage-quantity', auth, async (req, res) => {
       timestamp: now,
     } as UsageRecord);
 
+    logger.info('Usage quantity added', {
+      subscriptionItemId: subscriptionItem.id,
+      subscriptionId: subscription.id,
+      quantity,
+      timestamp: now,
+      requestedBy: req.user?.did,
+    });
+
     if (subscription.billing_thresholds?.amount_gte) {
       usageRecordQueue.push({
         id: `usage-${subscription.id}`,
         job: { subscriptionId: subscription.id, subscriptionItemId: subscriptionItem.id },
       });
+      logger.info('Usage record pushed to queue', {
+        subscriptionId: subscription.id,
+        subscriptionItemId: subscriptionItem.id,
+      });
     }
 
     await forwardUsageRecordToStripe(subscriptionItem, {
@@ -210,6 +240,13 @@ router.post('/:id/add-usage-quantity', auth, async (req, res) => {
       timestamp: now,
       action: 'increment',
     });
+    logger.info('Usage record forwarded to Stripe', {
+      subscriptionItemId: subscriptionItem.id,
+      quantity,
+      timestamp: now,
+      action: 'increment',
+    });
+
     return res.json(usageRecord);
   } catch (err) {
     console.error(err);

package/api/src/routes/subscriptions.ts

@@ -38,7 +38,6 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { PricingTable } from '../store/models/pricing-table';
 import { Product } from '../store/models/product';
-import { Refund } from '../store/models/refund';
 import { SetupIntent } from '../store/models/setup-intent';
 import { Subscription, TSubscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
@@ -46,6 +45,8 @@ import type { LineItem, ServiceAction, SubscriptionUpdateItem } from '../store/m
 import { UsageRecord } from '../store/models/usage-record';
 import { cleanupInvoiceAndItems, ensureInvoiceAndItems } from './connect/shared';
 import { createUsageRecordQueryFn } from './usage-records';
+import { SubscriptionWillCanceledSchedule } from '../crons/subscription-will-canceled';
+import { getTokenByAddress } from '../integrations/arcblock/stake';
 
 const router = Router();
 const auth = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -377,58 +378,43 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     }
   }
 
-  await subscription.update(updates);
-
   // trigger refund
   if (updates.cancel_at < subscription.current_period_end && refund !== 'none') {
     if (['owner', 'admin'].includes(req.user?.role as string) === false) {
-      return res.status(403).json({ error: 'Not authorized to perform this action' });
+      return res.status(403).json({ error: 'Not authorized to refund' });
     }
-
     const result = await getSubscriptionRefundSetup(subscription, updates.cancel_at);
     if (result.unused !== '0') {
-      const item = await Refund.create({
-        type: 'refund',
-        livemode: subscription.livemode,
-        amount: refund === 'last' ? result.total : result.unused,
-        description: 'refund_transfer_on_subscription_cancel',
-        status: 'pending',
-        reason: 'requested_by_admin',
-        currency_id: subscription.currency_id,
-        customer_id: subscription.customer_id,
-        payment_method_id: subscription.default_payment_method_id,
-        payment_intent_id: result.lastInvoice.payment_intent_id as string,
-        invoice_id: result.lastInvoice.id,
-        subscription_id: subscription.id,
-        attempt_count: 0,
-        attempted: false,
-        next_attempt: 0,
-        last_attempt_error: null,
-        starting_balance: '0',
-        ending_balance: '0',
-        starting_token_balance: {},
-        ending_token_balance: {},
-        metadata: {
-          requested_by: req.user?.did,
-          unused_period_start: refund === 'last' ? subscription.current_period_start : updates.cancel_at,
-          unused_period_end: subscription.current_period_end,
-        },
-      });
-      logger.info('subscription cancel refund created', {
+      // @ts-ignore
+      updates.cancelation_details = {
+        ...(updates.cancelation_details || {}),
+        refund,
+        requested_by: req.user?.did,
+      };
+      logger.info('subscription cancel with refund', {
         ...req.params,
         ...req.body,
+        refund,
         ...pick(result, ['total', 'unused']),
-        item: item.toJSON(),
       });
     } else {
-      logger.info('subscription cancel refund skipped', {
+      logger.info('subscription cancel no refund', {
         ...req.params,
         ...req.body,
         ...pick(result, ['total', 'unused']),
       });
     }
   }
-
+  await subscription.update(updates);
+  await new SubscriptionWillCanceledSchedule().reScheduleSubscriptionTasks([subscription]);
+  logger.info('Update subscription for cancel request successful', {
+    subscriptionId: subscription.id,
+    customerId: subscription.customer_id,
+    reason: req.body.reason,
+    cancelAt: subscription.cancel_at,
+    requestedBy: req.user?.did,
+    updates,
+  });
   return res.json(subscription);
 });
 
@@ -455,7 +441,7 @@ router.put('/:id/recover', authPortal, async (req, res) => {
   }
 
   await doc.update({ cancel_at_period_end: false, cancel_at: 0, canceled_at: 0 });
-
+  await new SubscriptionWillCanceledSchedule().deleteScheduleSubscriptionJobs([doc]);
   // reschedule jobs
   subscriptionQueue
     .delete(`cancel-${doc.id}`)
@@ -1126,7 +1112,11 @@ router.put('/:id', authPortal, async (req, res) => {
         }
       }
     }
-
+    logger.info('Subscription updated successfully', {
+      subscriptionId: subscription.id,
+      updatedFields: Object.keys(updates),
+      newStatus: subscription.status,
+    });
     return res.json({ ...subscription.toJSON(), connectAction });
   } catch (err) {
     console.error(err);
@@ -1645,8 +1635,16 @@ router.delete('/:id', auth, async (req, res) => {
   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 });
-
+  logger.info('Subscription deleted successfully', {
+    subscriptionId: req.params.id,
+    deletedRelatedRecords: {
+      invoiceItems: await InvoiceItem.count({ where: { subscription_id: doc.id } }),
+      invoices: await Invoice.count({ where: { subscription_id: doc.id } }),
+      usageRecords: await UsageRecord.count({ where: { subscription_item_id: items.map((x) => x.id) } }),
+      subscriptionItems: items.length,
+    },
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -1712,6 +1710,12 @@ router.put('/:id/slash-stake', auth, async (req, res) => {
     return res.status(400).json({ error: 'Staking not found on subscription payment detail' });
   }
   try {
+    logger.warn('Stake slash initiated', {
+      subscriptionId: subscription.id,
+      slashReason: req.body.slashReason,
+      requestedBy: req.user?.did,
+    });
+
     await subscription.update({
       // @ts-ignore
       cancelation_details: {
@@ -1724,10 +1728,43 @@ router.put('/:id/slash-stake', auth, async (req, res) => {
       id: `slash-stake-${subscription.id}`,
       job: { subscriptionId: subscription.id },
     });
+    logger.info('Stake slash scheduled successfully', {
+      subscriptionId: subscription.id,
+      result,
+      slashReason: req.body.slashReason,
+      requestedBy: req.user?.did,
+      stakingAddress: address,
+    });
     return res.json(result);
   } catch (err) {
     logger.error('subscription slash stake failed', { subscription: subscription.id, error: err });
     return res.status(400).json({ error: err.message });
   }
 });
+
+// get payer token
+router.get('/:id/payer-token', authMine, async (req, res) => {
+  const subscription = await Subscription.findByPk(req.params.id);
+  if (!subscription) {
+    return res.status(400).json({ error: `Subscription(${req.params.id}) not found` });
+  }
+  const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+  if (!paymentMethod) {
+    return res.status(400).json({ error: `Payment method(${subscription.default_payment_method_id}) not found` });
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!paymentCurrency) {
+    return res.status(400).json({ error: `Payment currency(${subscription.currency_id}) not found` });
+  }
+
+  // @ts-ignore
+  const paymentAddress = subscription.payment_details?.[paymentMethod.type]?.payer ?? undefined;
+  if (!paymentAddress && ['ethereum', 'arcblock'].includes(paymentMethod.type)) {
+    return res.status(400).json({ error: `Payer not found on subscription payment detail: ${subscription.id}` });
+  }
+
+  const token = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
+  return res.json({ token, paymentAddress });
+});
 export default router;

package/api/src/routes/usage-records.ts

@@ -45,17 +45,36 @@ router.post('/', auth, async (req, res) => {
   });
   if (doc) {
     if (doc.billed) {
+      logger.info('UsageRecord updated', {
+        subscriptionItemId: raw.subscription_item_id,
+        timestamp: raw.timestamp,
+        newQuantity: raw.quantity,
+      });
       return res.status(400).json({ error: 'UsageRecord is immutable because already billed' });
     }
     if (req.body.action === 'increment') {
       await doc.increment('quantity', { by: raw.quantity });
+      logger.info('UsageRecord incremented', {
+        subscriptionItemId: raw.subscription_item_id,
+        timestamp: raw.timestamp,
+        incrementBy: raw.quantity,
+      });
     } else {
       if (subscription.billing_thresholds?.amount_gte) {
+        logger.warn('Invalid action for subscription with billing_thresholds', {
+          subscriptionId: subscription.id,
+          action: req.body.action,
+        });
         return res
           .status(400)
           .json({ error: 'UsageRecord action must be `increment` for subscriptions with billing_thresholds' });
       }
       await doc.update({ quantity: raw.quantity });
+      logger.info('UsageRecord updated', {
+        subscriptionItemId: raw.subscription_item_id,
+        timestamp: raw.timestamp,
+        newQuantity: raw.quantity,
+      });
     }
   } else {
     raw.livemode = req.livemode;
@@ -67,6 +86,10 @@ router.post('/', auth, async (req, res) => {
       id: `usage-${subscription.id}`,
       job: { subscriptionId: subscription.id, subscriptionItemId: item.id },
     });
+    logger.info('UsageRecord pushed to queue', {
+      subscriptionId: subscription.id,
+      subscriptionItemId: item.id,
+    });
   }
 
   await forwardUsageRecordToStripe(item, {
@@ -75,6 +98,12 @@ router.post('/', auth, async (req, res) => {
     action: req.body.action,
   });
 
+  logger.info('UsageRecord forwarded to Stripe', {
+    subscriptionItemId: item.id,
+    quantity: Number(raw.quantity),
+    timestamp: raw.timestamp,
+    action: req.body.action,
+  });
   return res.json(doc);
 });
 

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

@@ -24,6 +24,7 @@ export class Event extends Model<InferAttributes<Event>, InferCreationAttributes
   declare request: {
     id: string;
     idempotency_key: string;
+    requested_by?: string;
   };
 
   // Number of webhooks that have yet to be successfully delivered

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

@@ -64,6 +64,8 @@ export class Subscription extends Model<InferAttributes<Subscription>, InferCrea
     return_stake?: boolean;
     slash_stake?: boolean;
     slash_reason?: string;
+    refund?: LiteralUnion<'last' | 'proration' | 'none', string>;
+    requested_by?: string;
   };
 
   declare billing_cycle_anchor: number;

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

@@ -0,0 +1,54 @@
+import { getSimplifyDuration } from '../../src/libs/time';
+
+describe('getSimplifyDuration', () => {
+  const testCasesEn = [
+    { ms: 30 * 1000, expected: '30 seconds' },
+    { ms: 34 * 60 * 1000 + 30 * 1000, expected: '34 minutes' },
+    { ms: 59 * 60 * 1000, expected: '59 minutes' },
+    { ms: 60 * 60 * 1000, expected: '1 hour' },
+    { ms: 23 * 60 * 60 * 1000, expected: '23 hours' },
+    { ms: 24 * 60 * 60 * 1000, expected: '1 day' },
+    { ms: 24 * 60 * 60 * 1000 + 20 * 60 * 1000 + 30 * 1000, expected: '1 day' },
+    { ms: 25 * 24 * 60 * 60 * 1000 + 30 * 60 * 1000 + 10 * 1000, expected: '25 days' },
+    { ms: 32 * 24 * 60 * 60 * 1000 + 30 * 60 * 1000 + 12 * 1000, expected: '32 days' },
+    { ms: 60 * 24 * 60 * 60 * 1000 + 20 * 60 * 1000, expected: '60 days' },
+    { ms: 366 * 24 * 60 * 60 * 1000 + 20 * 60 * 1000, expected: '1 year' },
+  ];
+
+  const testCasesZh = [
+    { ms: 30 * 1000, expected: '30秒' },
+    { ms: 34 * 60 * 1000 + 30 * 1000, expected: '34分钟' },
+    { ms: 59 * 60 * 1000, expected: '59分钟' },
+    { ms: 60 * 60 * 1000, expected: '1小时' },
+    { ms: 23 * 60 * 60 * 1000, expected: '23小时' },
+    { ms: 24 * 60 * 60 * 1000, expected: '1天' },
+    { ms: 24 * 60 * 60 * 1000 + 20 * 60 * 1000 + 30 * 1000, expected: '1天' },
+    { ms: 25 * 24 * 60 * 60 * 1000 + 30 * 60 * 1000 + 10 * 1000, expected: '25天' },
+    { ms: 32 * 24 * 60 * 60 * 1000 + 30 * 60 * 1000 + 12 * 1000, expected: '32天' },
+    { ms: 60 * 24 * 60 * 60 * 1000 + 20 * 60 * 1000, expected: '60天' },
+    { ms: 366 * 24 * 60 * 60 * 1000 + 20 * 60 * 1000, expected: '1年' },
+  ];
+
+  test.each(testCasesEn)('should return $expected for $ms milliseconds in English', ({ ms, expected }) => {
+    expect(getSimplifyDuration(ms, 'en')).toBe(expected);
+  });
+
+  test.each(testCasesZh)('should return $expected for $ms milliseconds in Chinese', ({ ms, expected }) => {
+    expect(getSimplifyDuration(ms, 'zh')).toBe(expected);
+  });
+
+  test('should handle zero', () => {
+    expect(getSimplifyDuration(0, 'en')).toBe('0ms');
+    expect(getSimplifyDuration(0, 'zh')).toBe('0毫秒');
+  });
+
+  test('should handle negative values', () => {
+    expect(getSimplifyDuration(-24 * 60 * 60 * 1000, 'en')).toBe('-1 days');
+    expect(getSimplifyDuration(-24 * 60 * 60 * 1000, 'zh')).toBe('-1天');
+  });
+
+  test('should handle large number of days', () => {
+    expect(getSimplifyDuration(1000 * 24 * 60 * 60 * 1000, 'en')).toBe('2 years');
+    expect(getSimplifyDuration(1000 * 24 * 60 * 60 * 1000, 'zh')).toBe('2年');
+  });
+});