Merge pull request #148 from ExcelDsigN-tech/fix/optimize-getUpcomingSubscriptions

perf: optimize getUpcomingSubscriptions Date creation

Author: Smartdevs17

src/utils/__tests__/dummyData.test.ts

@@ -0,0 +1,140 @@
+import { getUpcomingSubscriptions, _clearUpcomingCache } from '../dummyData';
+import { Subscription, SubscriptionCategory, BillingCycle } from '../../types/subscription';
+
+/** Helper to build a minimal Subscription for testing. */
+const makeSub = (
+  overrides: Partial<Subscription> & { id: string; nextBillingDate: Date }
+): Subscription => ({
+  name: `Sub ${overrides.id}`,
+  description: '',
+  category: SubscriptionCategory.OTHER,
+  price: 9.99,
+  currency: 'USD',
+  billingCycle: BillingCycle.MONTHLY,
+  isActive: true,
+  isCryptoEnabled: false,
+  createdAt: new Date('2024-01-01'),
+  updatedAt: new Date('2024-01-01'),
+  ...overrides,
+});
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+describe('getUpcomingSubscriptions', () => {
+  beforeAll(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date('2024-06-15T12:00:00Z'));
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  beforeEach(() => {
+    _clearUpcomingCache();
+  });
+
+  const NOW = new Date('2024-06-15T12:00:00Z').getTime();
+
+  it('returns active subscriptions within the next 7 days', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW + 1 * DAY_MS) }),
+      makeSub({ id: '2', nextBillingDate: new Date(NOW + 6 * DAY_MS) }),
+    ];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe('1');
+    expect(result[1].id).toBe('2');
+  });
+
+  it('excludes inactive subscriptions', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW + 1 * DAY_MS), isActive: false }),
+      makeSub({ id: '2', nextBillingDate: new Date(NOW + 2 * DAY_MS) }),
+    ];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('2');
+  });
+
+  it('excludes subscriptions beyond 7 days', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW + 8 * DAY_MS) }),
+      makeSub({ id: '2', nextBillingDate: new Date(NOW + 15 * DAY_MS) }),
+    ];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result).toHaveLength(0);
+  });
+
+  it('excludes subscriptions in the past', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW - 1 * DAY_MS) }),
+    ];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result).toHaveLength(0);
+  });
+
+  it('returns results sorted by billing date ascending', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: 'c', nextBillingDate: new Date(NOW + 5 * DAY_MS) }),
+      makeSub({ id: 'a', nextBillingDate: new Date(NOW + 1 * DAY_MS) }),
+      makeSub({ id: 'b', nextBillingDate: new Date(NOW + 3 * DAY_MS) }),
+    ];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result.map((s) => s.id)).toEqual(['a', 'b', 'c']);
+  });
+
+  it('includes subscriptions due exactly today (now)', () => {
+    const subs: Subscription[] = [makeSub({ id: '1', nextBillingDate: new Date(NOW) })];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result).toHaveLength(1);
+  });
+
+  it('includes subscriptions due exactly at the 7-day boundary', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW + 7 * DAY_MS) }),
+    ];
+
+    const result = getUpcomingSubscriptions(subs);
+    expect(result).toHaveLength(1);
+  });
+
+  it('handles empty array', () => {
+    expect(getUpcomingSubscriptions([])).toEqual([]);
+  });
+
+  it('handles null / undefined gracefully', () => {
+    expect(getUpcomingSubscriptions(null as unknown as Subscription[])).toEqual([]);
+    expect(getUpcomingSubscriptions(undefined as unknown as Subscription[])).toEqual([]);
+  });
+
+  it('returns cached result for the same input reference', () => {
+    const subs: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW + 1 * DAY_MS) }),
+    ];
+
+    const first = getUpcomingSubscriptions(subs);
+    const second = getUpcomingSubscriptions(subs);
+    expect(first).toBe(second); // Same reference (===) means cache hit
+  });
+
+  it('invalidates cache when input reference changes', () => {
+    const subs1: Subscription[] = [
+      makeSub({ id: '1', nextBillingDate: new Date(NOW + 1 * DAY_MS) }),
+    ];
+    const subs2: Subscription[] = [
+      makeSub({ id: '2', nextBillingDate: new Date(NOW + 2 * DAY_MS) }),
+    ];
+
+    const first = getUpcomingSubscriptions(subs1);
+    const second = getUpcomingSubscriptions(subs2);
+    expect(first).not.toBe(second);
+    expect(second[0].id).toBe('2');
+  });
+});

src/utils/dummyData.ts

@@ -151,21 +151,57 @@ export const dummySubscriptions: Subscription[] = [
   },
 ];
 
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const CACHE_TTL_MS = 60_000;
+
+let _cache: {
+  ref: Subscription[];
+  len: number;
+  ts: number;
+  result: Subscription[];
+} | null = null;
+
+/** Convert a Date, string, or numeric timestamp to a millisecond timestamp. */
+const toTimestamp = (d: Date | string | number): number =>
+  typeof d === 'number' ? d : d instanceof Date ? d.getTime() : new Date(d).getTime();
+
+/**
+ * Clear the internal memoization cache.
+ * Exposed for testing purposes only.
+ */
+export const _clearUpcomingCache = (): void => {
+  _cache = null;
+};
+
 export const getUpcomingSubscriptions = (subscriptions: Subscription[]): Subscription[] => {
   if (!subscriptions || !Array.isArray(subscriptions)) {
     return [];
   }
 
-  const today = new Date();
-  const nextWeek = new Date(today.getTime() + 7 * 24 * 60 * 60 * 1000);
+  const nowTs = Date.now();
 
-  return subscriptions
-    .filter((sub) => sub.isActive)
+  // Return cached result if input reference unchanged and cache is fresh
+  if (
+    _cache &&
+    _cache.ref === subscriptions &&
+    _cache.len === subscriptions.length &&
+    nowTs - _cache.ts < CACHE_TTL_MS
+  ) {
+    return _cache.result;
+  }
+
+  const nextWeekTs = nowTs + SEVEN_DAYS_MS;
+
+  const result = subscriptions
     .filter((sub) => {
-      const billingDate = new Date(sub.nextBillingDate);
-      return billingDate >= today && billingDate <= nextWeek;
+      if (!sub.isActive) return false;
+      const ts = toTimestamp(sub.nextBillingDate);
+      return ts >= nowTs && ts <= nextWeekTs;
     })
-    .sort((a, b) => new Date(a.nextBillingDate).getTime() - new Date(b.nextBillingDate).getTime());
+    .sort((a, b) => toTimestamp(a.nextBillingDate) - toTimestamp(b.nextBillingDate));
+
+  _cache = { ref: subscriptions, len: subscriptions.length, ts: nowTs, result };
+  return result;
 };
 
 export const getTotalMonthlySpending = (subscriptions: Subscription[]): number => {