@winible/winible-typed 2.118.0 → 2.120.0

package/utils/cacheService/cacheService.test.ts

@@ -643,4 +643,439 @@ describe('CacheService', () => {
       expect(result).toEqual({ value: null, text: 'example' });
     });
   });
+
+  describe('Sorted Set Operations (ZSET)', () => {
+    describe('zadd', () => {
+      it('should add single member with score to sorted set', async () => {
+        const result = await cacheService.zadd('leaderboard', [
+          { score: 100, member: 'player1' },
+        ]);
+        expect(result).toBe(1);
+
+        const count = await cacheService.zcard('leaderboard');
+        expect(count).toBe(1);
+      });
+
+      it('should add multiple members with scores to sorted set', async () => {
+        const result = await cacheService.zadd('leaderboard', [
+          { score: 100, member: 'player1' },
+          { score: 200, member: 'player2' },
+          { score: 150, member: 'player3' },
+        ]);
+        expect(result).toBe(3);
+
+        const count = await cacheService.zcard('leaderboard');
+        expect(count).toBe(3);
+      });
+
+      it('should update score when member already exists', async () => {
+        await cacheService.zadd('scores', [{ score: 100, member: 'user1' }]);
+        const result = await cacheService.zadd('scores', [{ score: 200, member: 'user1' }]);
+
+        // zadd returns 0 when updating existing member
+        expect(result).toBe(0);
+
+        const score = await cacheService.zscore('scores', 'user1');
+        expect(score).toBe(200);
+      });
+
+      it('should handle floating point scores', async () => {
+        const result = await cacheService.zadd('ratings', [
+          { score: 4.5, member: 'item1' },
+          { score: 3.2, member: 'item2' },
+          { score: 4.8, member: 'item3' },
+        ]);
+        expect(result).toBe(3);
+
+        const score = await cacheService.zscore('ratings', 'item1');
+        expect(score).toBe(4.5);
+      });
+
+      it('should handle negative scores', async () => {
+        const result = await cacheService.zadd('deltas', [
+          { score: -10, member: 'loss1' },
+          { score: 5, member: 'gain1' },
+          { score: -3, member: 'loss2' },
+        ]);
+        expect(result).toBe(3);
+
+        const score = await cacheService.zscore('deltas', 'loss1');
+        expect(score).toBe(-10);
+      });
+
+      it('should return 0 when not connected', async () => {
+        await cacheService.disconnect();
+        const result = await cacheService.zadd('test', [{ score: 100, member: 'item' }]);
+        expect(result).toBe(0);
+      });
+    });
+
+    describe('zrevrange', () => {
+      beforeEach(async () => {
+        await cacheService.zadd('leaderboard', [
+          { score: 100, member: 'player1' },
+          { score: 300, member: 'player2' },
+          { score: 200, member: 'player3' },
+          { score: 400, member: 'player4' },
+          { score: 150, member: 'player5' },
+        ]);
+      });
+
+      it('should get members in descending order by score', async () => {
+        const members = await cacheService.zrevrange('leaderboard', 0, 2);
+        expect(members).toEqual(['player4', 'player2', 'player3']);
+      });
+
+      it('should get all members when range covers entire set', async () => {
+        const members = await cacheService.zrevrange('leaderboard', 0, -1);
+        expect(members).toEqual(['player4', 'player2', 'player3', 'player5', 'player1']);
+      });
+
+      it('should get members with scores when withScores is true', async () => {
+        const result = await cacheService.zrevrange('leaderboard', 0, 2, true) as Array<{ member: string; score: number }>;
+        expect(result).toHaveLength(3);
+        expect(result[0]).toEqual({ member: 'player4', score: 400 });
+        expect(result[1]).toEqual({ member: 'player2', score: 300 });
+        expect(result[2]).toEqual({ member: 'player3', score: 200 });
+      });
+
+      it('should handle pagination with cursor ranges', async () => {
+        const firstPage = await cacheService.zrevrange('leaderboard', 0, 1);
+        expect(firstPage).toEqual(['player4', 'player2']);
+
+        const secondPage = await cacheService.zrevrange('leaderboard', 2, 3);
+        expect(secondPage).toEqual(['player3', 'player5']);
+      });
+
+      it('should return empty array when range is out of bounds', async () => {
+        const members = await cacheService.zrevrange('leaderboard', 10, 20);
+        expect(members).toEqual([]);
+      });
+
+      it('should return empty array for non-existent key', async () => {
+        const members = await cacheService.zrevrange('nonexistent', 0, -1);
+        expect(members).toEqual([]);
+      });
+
+      it('should return empty array when not connected', async () => {
+        await cacheService.disconnect();
+        const members = await cacheService.zrevrange('leaderboard', 0, -1);
+        expect(members).toEqual([]);
+      });
+
+      it('should handle single member result', async () => {
+        const members = await cacheService.zrevrange('leaderboard', 0, 0);
+        expect(members).toEqual(['player4']);
+      });
+
+      it('should handle negative indices', async () => {
+        const members = await cacheService.zrevrange('leaderboard', -2, -1);
+        expect(members).toEqual(['player5', 'player1']);
+      });
+    });
+
+    describe('zcard', () => {
+      it('should return 0 for non-existent sorted set', async () => {
+        const count = await cacheService.zcard('nonexistent');
+        expect(count).toBe(0);
+      });
+
+      it('should return count of members in sorted set', async () => {
+        await cacheService.zadd('trending', [
+          { score: 10, member: 'item1' },
+          { score: 20, member: 'item2' },
+          { score: 15, member: 'item3' },
+        ]);
+
+        const count = await cacheService.zcard('trending');
+        expect(count).toBe(3);
+      });
+
+      it('should return updated count after adding more members', async () => {
+        await cacheService.zadd('posts', [{ score: 5, member: 'post1' }]);
+        let count = await cacheService.zcard('posts');
+        expect(count).toBe(1);
+
+        await cacheService.zadd('posts', [
+          { score: 10, member: 'post2' },
+          { score: 7, member: 'post3' },
+        ]);
+        count = await cacheService.zcard('posts');
+        expect(count).toBe(3);
+      });
+
+      it('should return same count when updating existing member', async () => {
+        await cacheService.zadd('votes', [
+          { score: 100, member: 'comment1' },
+          { score: 50, member: 'comment2' },
+        ]);
+
+        let count = await cacheService.zcard('votes');
+        expect(count).toBe(2);
+
+        // Update score of existing member
+        await cacheService.zadd('votes', [{ score: 150, member: 'comment1' }]);
+        count = await cacheService.zcard('votes');
+        expect(count).toBe(2);
+      });
+
+      it('should return 0 when not connected', async () => {
+        await cacheService.disconnect();
+        const count = await cacheService.zcard('test');
+        expect(count).toBe(0);
+      });
+
+      it('should handle large sorted sets', async () => {
+        const members = Array.from({ length: 100 }, (_, i) => ({
+          score: i,
+          member: `item${i}`,
+        }));
+        await cacheService.zadd('large-set', members);
+
+        const count = await cacheService.zcard('large-set');
+        expect(count).toBe(100);
+      });
+    });
+
+    describe('zscore', () => {
+      beforeEach(async () => {
+        await cacheService.zadd('rankings', [
+          { score: 100, member: 'user1' },
+          { score: 200, member: 'user2' },
+          { score: 150.5, member: 'user3' },
+        ]);
+      });
+
+      it('should return score for existing member', async () => {
+        const score = await cacheService.zscore('rankings', 'user1');
+        expect(score).toBe(100);
+      });
+
+      it('should return null for non-existent member', async () => {
+        const score = await cacheService.zscore('rankings', 'nonexistent');
+        expect(score).toBeNull();
+      });
+
+      it('should return null for non-existent key', async () => {
+        const score = await cacheService.zscore('nonexistent', 'user1');
+        expect(score).toBeNull();
+      });
+
+      it('should handle floating point scores', async () => {
+        const score = await cacheService.zscore('rankings', 'user3');
+        expect(score).toBe(150.5);
+      });
+
+      it('should return updated score after member update', async () => {
+        let score = await cacheService.zscore('rankings', 'user1');
+        expect(score).toBe(100);
+
+        await cacheService.zadd('rankings', [{ score: 300, member: 'user1' }]);
+        score = await cacheService.zscore('rankings', 'user1');
+        expect(score).toBe(300);
+      });
+
+      it('should handle negative scores', async () => {
+        await cacheService.zadd('deltas', [{ score: -42.5, member: 'negative' }]);
+        const score = await cacheService.zscore('deltas', 'negative');
+        expect(score).toBe(-42.5);
+      });
+
+      it('should return null when not connected', async () => {
+        await cacheService.disconnect();
+        const score = await cacheService.zscore('rankings', 'user1');
+        expect(score).toBeNull();
+      });
+    });
+
+    describe('zremrangebyrank', () => {
+      beforeEach(async () => {
+        await cacheService.zadd('cleanup', [
+          { score: 10, member: 'item1' },
+          { score: 20, member: 'item2' },
+          { score: 30, member: 'item3' },
+          { score: 40, member: 'item4' },
+          { score: 50, member: 'item5' },
+        ]);
+      });
+
+      it('should remove members by rank range (ascending)', async () => {
+        const removed = await cacheService.zremrangebyrank('cleanup', 0, 1);
+        expect(removed).toBe(2);
+
+        const remaining = await cacheService.zcard('cleanup');
+        expect(remaining).toBe(3);
+
+        // Verify lowest scores were removed
+        const members = await cacheService.zrevrange('cleanup', 0, -1);
+        expect(members).toEqual(['item5', 'item4', 'item3']);
+      });
+
+      it('should remove all members when range covers entire set', async () => {
+        const removed = await cacheService.zremrangebyrank('cleanup', 0, -1);
+        expect(removed).toBe(5);
+
+        const count = await cacheService.zcard('cleanup');
+        expect(count).toBe(0);
+      });
+
+      it('should remove single member', async () => {
+        const removed = await cacheService.zremrangebyrank('cleanup', 0, 0);
+        expect(removed).toBe(1);
+
+        const count = await cacheService.zcard('cleanup');
+        expect(count).toBe(4);
+      });
+
+      it('should handle negative indices', async () => {
+        // Remove last 2 members (highest scores)
+        const removed = await cacheService.zremrangebyrank('cleanup', -2, -1);
+        expect(removed).toBe(2);
+
+        const members = await cacheService.zrevrange('cleanup', 0, -1);
+        expect(members).toEqual(['item3', 'item2', 'item1']);
+      });
+
+      it('should return 0 for non-existent key', async () => {
+        const removed = await cacheService.zremrangebyrank('nonexistent', 0, 10);
+        expect(removed).toBe(0);
+      });
+
+      it('should return 0 when range is out of bounds', async () => {
+        const removed = await cacheService.zremrangebyrank('cleanup', 10, 20);
+        expect(removed).toBe(0);
+
+        const count = await cacheService.zcard('cleanup');
+        expect(count).toBe(5);
+      });
+
+      it('should return 0 when not connected', async () => {
+        await cacheService.disconnect();
+        const removed = await cacheService.zremrangebyrank('cleanup', 0, 1);
+        expect(removed).toBe(0);
+      });
+
+      it('should remove middle range of members', async () => {
+        const removed = await cacheService.zremrangebyrank('cleanup', 1, 3);
+        expect(removed).toBe(3);
+
+        const members = await cacheService.zrevrange('cleanup', 0, -1);
+        expect(members).toEqual(['item5', 'item1']);
+      });
+
+      it('should handle cleanup of oldest entries to maintain limit', async () => {
+        // Add 100 items
+        const items = Array.from({ length: 100 }, (_, i) => ({
+          score: i,
+          member: `fixture${i}`,
+        }));
+        await cacheService.zadd('trending-fixtures', items);
+
+        const initialCount = await cacheService.zcard('trending-fixtures');
+        expect(initialCount).toBe(100);
+
+        // Keep only top 50 by removing bottom 50 (ranks 0-49)
+        const removed = await cacheService.zremrangebyrank('trending-fixtures', 0, 49);
+        expect(removed).toBe(50);
+
+        const finalCount = await cacheService.zcard('trending-fixtures');
+        expect(finalCount).toBe(50);
+
+        // Verify highest scores remain
+        const topMember = await cacheService.zrevrange('trending-fixtures', 0, 0);
+        expect(topMember).toEqual(['fixture99']);
+      });
+    });
+
+    describe('ZSET integration scenarios', () => {
+      it('should support trending fixtures use case', async () => {
+        // Add trending fixtures with bet counts
+        await cacheService.zadd('trending-fixtures', [
+          { score: 15, member: 'fixture-abc' },
+          { score: 42, member: 'fixture-def' },
+          { score: 28, member: 'fixture-ghi' },
+          { score: 9, member: 'fixture-jkl' },
+        ]);
+
+        // Get top 3 trending fixtures
+        const topFixtures = await cacheService.zrevrange('trending-fixtures', 0, 2);
+        expect(topFixtures).toEqual(['fixture-def', 'fixture-ghi', 'fixture-abc']);
+
+        // Get fixture with score
+        const withScores = await cacheService.zrevrange('trending-fixtures', 0, 0, true) as Array<{ member: string; score: number }>;
+        expect(withScores[0]).toEqual({ member: 'fixture-def', score: 42 });
+
+        // Check total count
+        const total = await cacheService.zcard('trending-fixtures');
+        expect(total).toBe(4);
+      });
+
+      it('should support pagination for infinite scroll', async () => {
+        // Add 50 fixtures
+        const fixtures = Array.from({ length: 50 }, (_, i) => ({
+          score: 50 - i, // Descending scores
+          member: `fixture-${i}`,
+        }));
+        await cacheService.zadd('paginated-fixtures', fixtures);
+
+        // First page (0-19)
+        const page1 = await cacheService.zrevrange('paginated-fixtures', 0, 19);
+        expect(page1).toHaveLength(20);
+        expect(page1[0]).toBe('fixture-0'); // Highest score
+
+        // Second page (20-39)
+        const page2 = await cacheService.zrevrange('paginated-fixtures', 20, 39);
+        expect(page2).toHaveLength(20);
+        expect(page2[0]).toBe('fixture-20');
+
+        // Last page (40-49)
+        const page3 = await cacheService.zrevrange('paginated-fixtures', 40, 49);
+        expect(page3).toHaveLength(10);
+
+        // Beyond last page
+        const page4 = await cacheService.zrevrange('paginated-fixtures', 50, 69);
+        expect(page4).toHaveLength(0);
+      });
+
+      it('should update trending fixture score when bet count changes', async () => {
+        await cacheService.zadd('live-trending', [
+          { score: 10, member: 'fixture-123' },
+        ]);
+
+        let score = await cacheService.zscore('live-trending', 'fixture-123');
+        expect(score).toBe(10);
+
+        // Simulate bet count increase
+        await cacheService.zadd('live-trending', [
+          { score: 25, member: 'fixture-123' },
+        ]);
+
+        score = await cacheService.zscore('live-trending', 'fixture-123');
+        expect(score).toBe(25);
+
+        // Verify count didn't change
+        const count = await cacheService.zcard('live-trending');
+        expect(count).toBe(1);
+      });
+
+      it('should maintain top 100 limit by removing oldest entries', async () => {
+        // Add 120 fixtures
+        const fixtures = Array.from({ length: 120 }, (_, i) => ({
+          score: Math.floor(Math.random() * 1000),
+          member: `fixture-${i}`,
+        }));
+        await cacheService.zadd('limited-trending', fixtures);
+
+        let count = await cacheService.zcard('limited-trending');
+        expect(count).toBe(120);
+
+        // Remove bottom 20 to keep only top 100
+        const removed = await cacheService.zremrangebyrank('limited-trending', 0, 19);
+        expect(removed).toBe(20);
+
+        count = await cacheService.zcard('limited-trending');
+        expect(count).toBe(100);
+      });
+    });
+  });
 });

package/utils/cacheService/cacheService.ts

@@ -57,14 +57,32 @@ class CacheService {
       additionalData?: any;
     }
   ): void {
-    if (this.errorHandler) {
-      error.name = context.method;
-      this.errorHandler(error, undefined, context);
-    } else {
-      // Fallback to logger if no error handler is set
+    try {
+      if (this.errorHandler) {
+        // Override the name property using Object.defineProperty to avoid read-only restriction
+        if (context?.method) {
+          Object.defineProperty(error, 'name', {
+            value: context.method,
+            writable: true,
+            enumerable: false,
+            configurable: true,
+          });
+        }
+        this.errorHandler(error, undefined, context);
+      } else {
+        // Fallback to logger if no error handler is set
+        logger(message, {
+          level: "error",
+          method: context?.method || "CacheService",
+          action: context?.action || "error",
+          error,
+          additionalData: context?.additionalData,
+        });
+      }
+    } catch (error) {
       logger(message, {
         level: "error",
-        method: context?.method || "CacheService",
+        method: "CacheService.ErrorHandler",
         action: context?.action || "error",
         error,
         additionalData: context?.additionalData,
@@ -615,6 +633,169 @@ class CacheService {
     }
   }
 
+  /**
+   * Add members with scores to a sorted set
+   * @param key - The sorted set key
+   * @param members - Array of member-score pairs
+   * @returns The number of elements added to the sorted set (not including elements already existing for which the score was updated)
+   */
+  async zadd(
+    key: string,
+    members: Array<{ score: number; member: string }>
+  ): Promise<number> {
+    if (!this.isConnected) return 0;
+
+    try {
+      const args: Array<number | string> = [];
+      members.forEach(({ score, member }) => {
+        args.push(score, member);
+      });
+      const result = await this.client!.zadd(key, ...args);
+      return result;
+    } catch (error) {
+      this.handleError(error, null, {
+        method: "CacheService.zadd",
+        action: "error",
+        additionalData: {
+          message: "Failed to add members to sorted set",
+          key,
+          count: members.length,
+        },
+      });
+      return 0;
+    }
+  }
+
+  /**
+   * Get members from a sorted set by score, highest to lowest (descending order)
+   * @param key - The sorted set key
+   * @param start - Start index (0-based)
+   * @param stop - Stop index (-1 for all remaining)
+   * @param withScores - Whether to include scores in the result
+   * @returns Array of members, or array of {member, score} objects if withScores is true
+   */
+  async zrevrange(
+    key: string,
+    start: number,
+    stop: number,
+    withScores?: boolean
+  ): Promise<string[] | Array<{ member: string; score: number }>> {
+    if (!this.isConnected) return [];
+
+    try {
+      if (withScores) {
+        const result = await this.client!.zrevrange(
+          key,
+          start,
+          stop,
+          "WITHSCORES"
+        );
+        const pairs: Array<{ member: string; score: number }> = [];
+        for (let i = 0; i < result.length; i += 2) {
+          pairs.push({
+            member: result[i],
+            score: parseFloat(result[i + 1]),
+          });
+        }
+        return pairs;
+      } else {
+        return await this.client!.zrevrange(key, start, stop);
+      }
+    } catch (error) {
+      this.handleError(error, null, {
+        method: "CacheService.zrevrange",
+        action: "error",
+        additionalData: {
+          message: "Failed to get members from sorted set",
+          key,
+          start,
+          stop,
+        },
+      });
+      return [];
+    }
+  }
+
+  /**
+   * Get the number of members in a sorted set
+   * @param key - The sorted set key
+   * @returns The cardinality (number of members) of the sorted set
+   */
+  async zcard(key: string): Promise<number> {
+    if (!this.isConnected) return 0;
+
+    try {
+      return await this.client!.zcard(key);
+    } catch (error) {
+      this.handleError(error, null, {
+        method: "CacheService.zcard",
+        action: "error",
+        additionalData: {
+          message: "Failed to get cardinality of sorted set",
+          key,
+        },
+      });
+      return 0;
+    }
+  }
+
+  /**
+   * Get the score of a member in a sorted set
+   * @param key - The sorted set key
+   * @param member - The member to get the score for
+   * @returns The score of the member, or null if the member doesn't exist
+   */
+  async zscore(key: string, member: string): Promise<number | null> {
+    if (!this.isConnected) return null;
+
+    try {
+      const score = await this.client!.zscore(key, member);
+      return score !== null ? parseFloat(score) : null;
+    } catch (error) {
+      this.handleError(error, null, {
+        method: "CacheService.zscore",
+        action: "error",
+        additionalData: {
+          message: "Failed to get score from sorted set",
+          key,
+          member,
+        },
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Remove all members in a sorted set within the given rank range
+   * @param key - The sorted set key
+   * @param start - Start rank (0-based)
+   * @param stop - Stop rank
+   * @returns The number of members removed
+   */
+  async zremrangebyrank(
+    key: string,
+    start: number,
+    stop: number
+  ): Promise<number> {
+    if (!this.isConnected) return 0;
+
+    try {
+      return await this.client!.zremrangebyrank(key, start, stop);
+    } catch (error) {
+      this.handleError(error, null, {
+        method: "CacheService.zremrangebyrank",
+        action: "error",
+        additionalData: {
+          message: "Failed to remove members from sorted set by rank",
+          key,
+          start,
+          stop,
+        },
+      });
+      return 0;
+    }
+  }
+
   /**
    * Disconnect the cache client
    * Use this for graceful shutdown

package/utils/index.ts

@@ -2,3 +2,4 @@ export { default as campaignUtils } from "./campaignUtils";
 export { default as generalUtils } from "./generalUtils";
 export { default as logger } from "./logger";
 export { default as CacheService, cacheService } from "./cacheService/cacheService";
+export { initializeOpenSearchClient } from "./openSearch/openSearchClient";