payment-kit 1.25.8 → 1.26.0

package/api/tests/libs/archive-lock.spec.ts

@@ -0,0 +1,130 @@
+import { acquireArchiveLock, releaseArchiveLock } from '../../src/libs/archive/lock';
+import { ArchiveLock } from '../../src/store/models/archive-lock';
+
+jest.mock('../../src/store/models/archive-lock', () => {
+  const mockArchiveLock = {
+    sequelize: {
+      transaction: jest.fn(),
+    },
+    findByPk: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+  };
+  return { ArchiveLock: mockArchiveLock };
+});
+
+describe('archive/lock', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('acquireArchiveLock', () => {
+    it('should return false when sequelize is not available', async () => {
+      (ArchiveLock as any).sequelize = null;
+
+      const result = await acquireArchiveLock('instance-1');
+
+      expect(result).toBe(false);
+    });
+
+    it('should create new lock when no existing lock', async () => {
+      const mockTransaction = jest.fn();
+      (ArchiveLock as any).sequelize = {
+        transaction: jest.fn((callback: any) => callback(mockTransaction)),
+      };
+      (ArchiveLock.findByPk as jest.Mock).mockResolvedValue(null);
+      (ArchiveLock.create as jest.Mock).mockResolvedValue({});
+
+      const result = await acquireArchiveLock('instance-1');
+
+      expect(result).toBe(true);
+      expect(ArchiveLock.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: 'archive_job',
+          locked_by: 'instance-1',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should acquire expired lock', async () => {
+      const mockTransaction = jest.fn();
+      const expiredLock = {
+        expires_at: Date.now() - 1000,
+        update: jest.fn().mockResolvedValue({}),
+      };
+      (ArchiveLock as any).sequelize = {
+        transaction: jest.fn((callback: any) => callback(mockTransaction)),
+      };
+      (ArchiveLock.findByPk as jest.Mock).mockResolvedValue(expiredLock);
+
+      const result = await acquireArchiveLock('instance-2');
+
+      expect(result).toBe(true);
+      expect(expiredLock.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          locked_by: 'instance-2',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should not acquire lock when held by another instance', async () => {
+      const mockTransaction = jest.fn();
+      const activeLock = {
+        expires_at: Date.now() + 60000,
+        locked_by: 'other-instance',
+      };
+      (ArchiveLock as any).sequelize = {
+        transaction: jest.fn((callback: any) => callback(mockTransaction)),
+      };
+      (ArchiveLock.findByPk as jest.Mock).mockResolvedValue(activeLock);
+
+      const result = await acquireArchiveLock('instance-1');
+
+      expect(result).toBe(false);
+    });
+
+    it('should acquire lock when expires_at is null (stale lock)', async () => {
+      const mockTransaction = jest.fn();
+      const staleLock = {
+        expires_at: null,
+        update: jest.fn().mockResolvedValue({}),
+      };
+      (ArchiveLock as any).sequelize = {
+        transaction: jest.fn((callback: any) => callback(mockTransaction)),
+      };
+      (ArchiveLock.findByPk as jest.Mock).mockResolvedValue(staleLock);
+
+      const result = await acquireArchiveLock('instance-1');
+
+      expect(result).toBe(true);
+      expect(staleLock.update).toHaveBeenCalled();
+    });
+  });
+
+  describe('releaseArchiveLock', () => {
+    it('should release lock for the given instance', async () => {
+      (ArchiveLock.update as jest.Mock).mockResolvedValue([1]);
+      (ArchiveLock as any).sequelize = { transaction: jest.fn() };
+
+      await releaseArchiveLock('instance-1');
+
+      expect(ArchiveLock.update).toHaveBeenCalledWith(
+        { locked_by: null, locked_at: null, expires_at: null },
+        { where: { id: 'archive_job', locked_by: 'instance-1' } }
+      );
+    });
+
+    it('should not release lock held by different instance', async () => {
+      (ArchiveLock.update as jest.Mock).mockResolvedValue([0]);
+      (ArchiveLock as any).sequelize = { transaction: jest.fn() };
+
+      await releaseArchiveLock('wrong-instance');
+
+      expect(ArchiveLock.update).toHaveBeenCalledWith(expect.anything(), {
+        where: { id: 'archive_job', locked_by: 'wrong-instance' },
+      });
+    });
+  });
+});

package/api/tests/libs/archive-policy.spec.ts

@@ -0,0 +1,255 @@
+import { Op } from 'sequelize';
+import { getArchiveDateField, buildArchiveQueryPlan } from '../../src/libs/archive/policy';
+import { TableRetentionPolicy } from '../../src/libs/archive/config';
+
+describe('archive/policy', () => {
+  describe('getArchiveDateField', () => {
+    it('should return updated_at when model has updated_at attribute', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          updated_at: {},
+          created_at: {},
+        },
+      } as any;
+
+      expect(getArchiveDateField(mockModel)).toBe('updated_at');
+    });
+
+    it('should return created_at when model only has created_at attribute', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          created_at: {},
+        },
+      } as any;
+
+      expect(getArchiveDateField(mockModel)).toBe('created_at');
+    });
+
+    it('should fallback to created_at when neither field exists', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          name: {},
+        },
+      } as any;
+
+      expect(getArchiveDateField(mockModel)).toBe('created_at');
+    });
+  });
+
+  describe('buildArchiveQueryPlan', () => {
+    const cutoffDate = new Date('2024-01-01T00:00:00Z');
+
+    it('should build basic query plan with date cutoff', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+      };
+
+      const { where, dateField } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+
+      expect(dateField).toBe('created_at');
+      expect(where.created_at).toBeDefined();
+      expect((where.created_at as any)[Op.lte]).toEqual(cutoffDate);
+    });
+
+    it('should use updated_at when available', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          updated_at: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+      };
+
+      const { where, dateField } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+
+      expect(dateField).toBe('updated_at');
+      expect(where.updated_at).toBeDefined();
+    });
+
+    it('should include archivableStatuses condition when model has status field', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          status: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        archivableStatuses: ['completed', 'canceled'],
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeDefined();
+      expect(conditions).toContainEqual({
+        status: { [Op.in]: ['completed', 'canceled'] },
+      });
+    });
+
+    it('should include excludeConditions.statuses when model has status field', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          status: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        excludeConditions: {
+          statuses: ['pending', 'processing'],
+        },
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeDefined();
+      expect(conditions).toContainEqual({
+        status: { [Op.notIn]: ['pending', 'processing'] },
+      });
+    });
+
+    it('should not add status conditions when model lacks status field', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        archivableStatuses: ['completed'],
+        excludeConditions: {
+          statuses: ['pending'],
+        },
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeUndefined();
+    });
+
+    it('should include custom condition wrapped with NOT()', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        excludeConditions: {
+          customCondition: 'pending_webhooks > 0',
+        },
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeDefined();
+      expect(conditions.length).toBe(1);
+      // Verify the Sequelize.literal wraps with NOT()
+      const literal = conditions[0];
+      expect(literal.val).toContain('NOT');
+      expect(literal.val).toContain('pending_webhooks > 0');
+    });
+
+    it('should combine multiple conditions with AND', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          status: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        archivableStatuses: ['completed'],
+        excludeConditions: {
+          statuses: ['pending'],
+          customCondition: 'active = 0',
+        },
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeDefined();
+      expect(conditions.length).toBe(3);
+    });
+
+    it('should handle empty archivableStatuses array', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          status: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        archivableStatuses: [],
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeUndefined();
+    });
+
+    it('should handle empty excludeConditions.statuses array', () => {
+      const mockModel = {
+        rawAttributes: {
+          id: {},
+          status: {},
+          created_at: {},
+        },
+      } as any;
+
+      const policy: TableRetentionPolicy = {
+        enabled: true,
+        retentionDays: 90,
+        excludeConditions: {
+          statuses: [],
+        },
+      };
+
+      const { where } = buildArchiveQueryPlan(mockModel, policy, cutoffDate);
+      const conditions = (where as any)[Op.and];
+
+      expect(conditions).toBeUndefined();
+    });
+  });
+});

package/api/tests/libs/archive-query.spec.ts

@@ -0,0 +1,267 @@
+import { queryArchive } from '../../src/libs/archive/query';
+
+import { listArchiveFiles, openArchiveSequelize } from '../../src/libs/archive/store';
+import { ArchiveMetadata } from '../../src/store/models/archive-metadata';
+
+jest.mock('../../src/libs/archive/store', () => ({
+  listArchiveFiles: jest.fn(),
+  openArchiveSequelize: jest.fn(),
+}));
+
+jest.mock('../../src/store/models/archive-metadata', () => ({
+  ArchiveMetadata: {
+    findOne: jest.fn(),
+    findAll: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/libs/logger', () => ({
+  __esModule: true,
+  default: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const mockListArchiveFiles = listArchiveFiles as jest.MockedFunction<typeof listArchiveFiles>;
+const mockOpenArchiveSequelize = openArchiveSequelize as jest.MockedFunction<typeof openArchiveSequelize>;
+const mockArchiveMetadataFindAll = (ArchiveMetadata as any).findAll as jest.MockedFunction<any>;
+
+describe('archive/query', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('queryArchive', () => {
+    it('should reject invalid table names', async () => {
+      await expect(
+        queryArchive({
+          table: 'DROP TABLE users;--',
+          from: Math.floor(Date.now() / 1000) - 86400,
+          page: 1,
+          limit: 10,
+        })
+      ).rejects.toThrow('Invalid table name');
+    });
+
+    it('should reject table names starting with numbers', async () => {
+      await expect(
+        queryArchive({
+          table: '123_table',
+          from: Math.floor(Date.now() / 1000) - 86400,
+          page: 1,
+          limit: 10,
+        })
+      ).rejects.toThrow('Invalid table name');
+    });
+
+    it('should accept valid table names', async () => {
+      mockListArchiveFiles.mockReturnValue([]);
+
+      const result = await queryArchive({
+        table: 'meter_events',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 1,
+        limit: 10,
+      });
+
+      expect(result).toEqual({ data: [], total: 0, archiveFiles: [] });
+    });
+
+    it('should return empty result when no archive files exist', async () => {
+      mockListArchiveFiles.mockReturnValue([]);
+
+      const result = await queryArchive({
+        table: 'invoices',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 1,
+        limit: 10,
+      });
+
+      expect(result.data).toHaveLength(0);
+      expect(result.total).toBe(0);
+      expect(result.archiveFiles).toHaveLength(0);
+    });
+
+    it('should query archive files and return paginated results', async () => {
+      const mockClose = jest.fn();
+      // Mock query: first call checks table existence, second call fetches data
+      const mockQuery = jest.fn().mockImplementation((sql: string) => {
+        if (sql.includes('sqlite_master')) {
+          return [[{ name: 'invoices' }]]; // Table exists
+        }
+        return [
+          { id: '1', created_at: new Date('2024-01-15') },
+          { id: '2', created_at: new Date('2024-01-14') },
+        ];
+      });
+
+      mockListArchiveFiles.mockReturnValue(['/tmp/archive-2024.db']);
+      mockOpenArchiveSequelize.mockReturnValue({
+        query: mockQuery,
+        close: mockClose,
+      } as any);
+      mockArchiveMetadataFindAll.mockResolvedValue([
+        {
+          id: 'meta-1',
+          query_count: 0,
+          query_actor_ids: [],
+          update: jest.fn(),
+        },
+      ]);
+
+      const result = await queryArchive({
+        table: 'invoices',
+        from: Math.floor(new Date('2024-01-01').getTime() / 1000),
+        to: Math.floor(new Date('2024-01-31').getTime() / 1000),
+        page: 1,
+        limit: 10,
+      });
+
+      expect(result.data).toHaveLength(2);
+      expect(result.total).toBe(2);
+      expect(mockClose).toHaveBeenCalled();
+    });
+
+    it('should skip archive files that do not have the requested table', async () => {
+      const mockClose = jest.fn();
+      // Return empty array for sqlite_master query (table doesn't exist)
+      const mockQuery = jest.fn().mockResolvedValue([[]]);
+
+      mockListArchiveFiles.mockReturnValue(['/tmp/archive-2024.db']);
+      mockOpenArchiveSequelize.mockReturnValue({
+        query: mockQuery,
+        close: mockClose,
+      } as any);
+
+      const result = await queryArchive({
+        table: 'nonexistent_table',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 1,
+        limit: 10,
+      });
+
+      expect(result.data).toHaveLength(0);
+      expect(mockClose).toHaveBeenCalled();
+    });
+
+    it('should handle query errors gracefully', async () => {
+      const mockClose = jest.fn();
+      const mockQuery = jest.fn().mockImplementation((sql: string) => {
+        if (sql.includes('sqlite_master')) {
+          return [[{ name: 'invoices' }]]; // Table exists
+        }
+        throw new Error('Query failed');
+      });
+
+      mockListArchiveFiles.mockReturnValue(['/tmp/archive-2024.db']);
+      mockOpenArchiveSequelize.mockReturnValue({
+        query: mockQuery,
+        close: mockClose,
+      } as any);
+
+      const result = await queryArchive({
+        table: 'invoices',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 1,
+        limit: 10,
+      });
+
+      expect(result.data).toHaveLength(0);
+      expect(mockClose).toHaveBeenCalled();
+    });
+
+    it('should apply customer_id filter correctly for regular tables', async () => {
+      const mockClose = jest.fn();
+      const mockQuery = jest.fn().mockImplementation((sql: string) => {
+        if (sql.includes('sqlite_master')) {
+          return [[{ name: 'invoices' }]];
+        }
+        return [];
+      });
+
+      mockListArchiveFiles.mockReturnValue(['/tmp/archive-2024.db']);
+      mockOpenArchiveSequelize.mockReturnValue({
+        query: mockQuery,
+        close: mockClose,
+      } as any);
+
+      await queryArchive({
+        table: 'invoices',
+        customer_id: 'cus_123',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 1,
+        limit: 10,
+      });
+
+      expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('customer_id = :customerId'), expect.any(Object));
+    });
+
+    it('should apply customer_id filter with json_extract for meter_events', async () => {
+      const mockClose = jest.fn();
+      const mockQuery = jest.fn().mockImplementation((sql: string) => {
+        if (sql.includes('sqlite_master')) {
+          return [[{ name: 'meter_events' }]];
+        }
+        return [];
+      });
+
+      mockListArchiveFiles.mockReturnValue(['/tmp/archive-2024.db']);
+      mockOpenArchiveSequelize.mockReturnValue({
+        query: mockQuery,
+        close: mockClose,
+      } as any);
+
+      await queryArchive({
+        table: 'meter_events',
+        customer_id: 'cus_123',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 1,
+        limit: 10,
+      });
+
+      expect(mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining("json_extract(payload, '$.customer_id')"),
+        expect.any(Object)
+      );
+    });
+
+    it('should paginate results correctly', async () => {
+      const mockClose = jest.fn();
+      const mockQuery = jest.fn().mockImplementation((sql: string) => {
+        if (sql.includes('sqlite_master')) {
+          return [[{ name: 'invoices' }]];
+        }
+        return Array.from({ length: 25 }, (_, i) => ({
+          id: String(i + 1),
+          created_at: new Date(Date.now() - i * 1000),
+        }));
+      });
+
+      mockListArchiveFiles.mockReturnValue(['/tmp/archive-2024.db']);
+      mockOpenArchiveSequelize.mockReturnValue({
+        query: mockQuery,
+        close: mockClose,
+      } as any);
+      mockArchiveMetadataFindAll.mockResolvedValue([
+        {
+          id: 'meta-1',
+          query_count: 0,
+          query_actor_ids: [],
+          update: jest.fn(),
+        },
+      ]);
+
+      const result = await queryArchive({
+        table: 'invoices',
+        from: Math.floor(Date.now() / 1000) - 86400,
+        page: 2,
+        limit: 10,
+      });
+
+      expect(result.data).toHaveLength(10);
+      expect(result.total).toBe(25);
+    });
+  });
+});