@adtrackify/at-service-common 3.19.25 → 4.0.0

package/dist/esm/__tests__/db/shopify-app-installs-db-service.spec.js

@@ -1,103 +1,103 @@
-jest.mock('../../clients/generic/dynamodb-client.js', () => ({
-    DynamoDbClient: {
-        safeGet: jest.fn(),
-        safeQueryByGSI: jest.fn(),
-        safeBatchGet: jest.fn(),
-        queryAll: jest.fn(),
-    },
-}));
-jest.mock('../../helpers/index.js', () => ({
-    Logger: {
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-        debug: jest.fn(),
-    },
-}));
-import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
-import { ShopifyAppInstallsDbService } from '../../services/db/shopify-app-installs-db-service.js';
-const mockSafeBatchGet = DynamoDbClient.safeBatchGet;
-const mockSafeGet = DynamoDbClient.safeGet;
-describe('ShopifyAppInstallsDbService', () => {
-    const TABLE_NAME = 'test-shopify-app-installs-table';
-    const TABLE_KEY = 'id';
-    const service = new ShopifyAppInstallsDbService(TABLE_NAME, TABLE_KEY);
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe('batchGetByIds', () => {
-        it('returns empty array for empty ids input', async () => {
-            mockSafeBatchGet.mockResolvedValueOnce([]);
-            const result = await service.batchGetByIds([]);
-            expect(result).toEqual([]);
-            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, []);
-        });
-        it('returns installs for single id', async () => {
-            const mockInstall = {
-                id: 'install-1',
-                shop: 'test-shop.myshopify.com',
-                pixelId: 'px-1',
-            };
-            mockSafeBatchGet.mockResolvedValueOnce([mockInstall]);
-            const result = await service.batchGetByIds(['install-1']);
-            expect(result).toEqual([mockInstall]);
-            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, [{ id: 'install-1' }]);
-        });
-        it('returns installs for multiple ids', async () => {
-            const mockInstalls = [
-                { id: 'install-1', shop: 'shop1.myshopify.com', pixelId: 'px-1' },
-                { id: 'install-2', shop: 'shop2.myshopify.com', pixelId: 'px-2' },
-                { id: 'install-3', shop: 'shop3.myshopify.com', pixelId: 'px-3' },
-            ];
-            mockSafeBatchGet.mockResolvedValueOnce(mockInstalls);
-            const result = await service.batchGetByIds(['install-1', 'install-2', 'install-3']);
-            expect(result).toEqual(mockInstalls);
-            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, [
-                { id: 'install-1' },
-                { id: 'install-2' },
-                { id: 'install-3' },
-            ]);
-        });
-        it('returns empty array when safeBatchGet returns null', async () => {
-            mockSafeBatchGet.mockResolvedValueOnce(null);
-            const result = await service.batchGetByIds(['install-1']);
-            expect(result).toEqual([]);
-        });
-        it('uses custom table key from constructor', async () => {
-            const customService = new ShopifyAppInstallsDbService(TABLE_NAME, 'customKey');
-            mockSafeBatchGet.mockResolvedValueOnce([]);
-            await customService.batchGetByIds(['install-1', 'install-2']);
-            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, [
-                { customKey: 'install-1' },
-                { customKey: 'install-2' },
-            ]);
-        });
-        it('uses default table key "id" when not specified', async () => {
-            const defaultKeyService = new ShopifyAppInstallsDbService('another-table');
-            mockSafeBatchGet.mockResolvedValueOnce([]);
-            await defaultKeyService.batchGetByIds(['install-1']);
-            expect(mockSafeBatchGet).toHaveBeenCalledWith('another-table', [{ id: 'install-1' }]);
-        });
-    });
-    describe('getShopifyAppInstallById', () => {
-        it('returns install when found', async () => {
-            const mockInstall = {
-                id: 'install-1',
-                shop: 'test-shop.myshopify.com',
-            };
-            mockSafeGet.mockResolvedValueOnce(mockInstall);
-            const result = await service.getShopifyAppInstallById('id', 'install-1');
-            expect(result).toEqual(mockInstall);
-            expect(mockSafeGet).toHaveBeenCalledWith(TABLE_NAME, 'id', 'install-1');
-        });
-        it('returns null when not found', async () => {
-            mockSafeGet.mockResolvedValueOnce(null);
-            const result = await service.getShopifyAppInstallById('id', 'nonexistent');
-            expect(result).toBeNull();
-        });
-    });
-});
+jest.mock('../../clients/generic/dynamodb-client.js', () => ({
+    DynamoDbClient: {
+        safeGet: jest.fn(),
+        safeQueryByGSI: jest.fn(),
+        safeBatchGet: jest.fn(),
+        queryAll: jest.fn(),
+    },
+}));
+jest.mock('../../helpers/index.js', () => ({
+    Logger: {
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn(),
+    },
+}));
+import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
+import { ShopifyAppInstallsDbService } from '../../services/db/shopify-app-installs-db-service.js';
+const mockSafeBatchGet = DynamoDbClient.safeBatchGet;
+const mockSafeGet = DynamoDbClient.safeGet;
+describe('ShopifyAppInstallsDbService', () => {
+    const TABLE_NAME = 'test-shopify-app-installs-table';
+    const TABLE_KEY = 'id';
+    const service = new ShopifyAppInstallsDbService(TABLE_NAME, TABLE_KEY);
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('batchGetByIds', () => {
+        it('returns empty array for empty ids input', async () => {
+            mockSafeBatchGet.mockResolvedValueOnce([]);
+            const result = await service.batchGetByIds([]);
+            expect(result).toEqual([]);
+            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, []);
+        });
+        it('returns installs for single id', async () => {
+            const mockInstall = {
+                id: 'install-1',
+                shop: 'test-shop.myshopify.com',
+                pixelId: 'px-1',
+            };
+            mockSafeBatchGet.mockResolvedValueOnce([mockInstall]);
+            const result = await service.batchGetByIds(['install-1']);
+            expect(result).toEqual([mockInstall]);
+            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, [{ id: 'install-1' }]);
+        });
+        it('returns installs for multiple ids', async () => {
+            const mockInstalls = [
+                { id: 'install-1', shop: 'shop1.myshopify.com', pixelId: 'px-1' },
+                { id: 'install-2', shop: 'shop2.myshopify.com', pixelId: 'px-2' },
+                { id: 'install-3', shop: 'shop3.myshopify.com', pixelId: 'px-3' },
+            ];
+            mockSafeBatchGet.mockResolvedValueOnce(mockInstalls);
+            const result = await service.batchGetByIds(['install-1', 'install-2', 'install-3']);
+            expect(result).toEqual(mockInstalls);
+            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, [
+                { id: 'install-1' },
+                { id: 'install-2' },
+                { id: 'install-3' },
+            ]);
+        });
+        it('returns empty array when safeBatchGet returns null', async () => {
+            mockSafeBatchGet.mockResolvedValueOnce(null);
+            const result = await service.batchGetByIds(['install-1']);
+            expect(result).toEqual([]);
+        });
+        it('uses custom table key from constructor', async () => {
+            const customService = new ShopifyAppInstallsDbService(TABLE_NAME, 'customKey');
+            mockSafeBatchGet.mockResolvedValueOnce([]);
+            await customService.batchGetByIds(['install-1', 'install-2']);
+            expect(mockSafeBatchGet).toHaveBeenCalledWith(TABLE_NAME, [
+                { customKey: 'install-1' },
+                { customKey: 'install-2' },
+            ]);
+        });
+        it('uses default table key "id" when not specified', async () => {
+            const defaultKeyService = new ShopifyAppInstallsDbService('another-table');
+            mockSafeBatchGet.mockResolvedValueOnce([]);
+            await defaultKeyService.batchGetByIds(['install-1']);
+            expect(mockSafeBatchGet).toHaveBeenCalledWith('another-table', [{ id: 'install-1' }]);
+        });
+    });
+    describe('getShopifyAppInstallById', () => {
+        it('returns install when found', async () => {
+            const mockInstall = {
+                id: 'install-1',
+                shop: 'test-shop.myshopify.com',
+            };
+            mockSafeGet.mockResolvedValueOnce(mockInstall);
+            const result = await service.getShopifyAppInstallById('id', 'install-1');
+            expect(result).toEqual(mockInstall);
+            expect(mockSafeGet).toHaveBeenCalledWith(TABLE_NAME, 'id', 'install-1');
+        });
+        it('returns null when not found', async () => {
+            mockSafeGet.mockResolvedValueOnce(null);
+            const result = await service.getShopifyAppInstallById('id', 'nonexistent');
+            expect(result).toBeNull();
+        });
+    });
+});
 //# sourceMappingURL=shopify-app-installs-db-service.spec.js.map

package/dist/esm/__tests__/db/subscriptions-db-service.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/__tests__/db/subscriptions-db-service.spec.js

@@ -1,94 +1,94 @@
-jest.mock('../../clients/generic/dynamodb-client.js', () => ({
-    DynamoDbClient: {
-        safeGet: jest.fn(),
-        safeQueryByGSI: jest.fn(),
-        safeBatchQueryByGSI: jest.fn(),
-    },
-}));
-jest.mock('../../helpers/index.js', () => ({
-    Logger: {
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-        debug: jest.fn(),
-    },
-}));
-import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
-import { SubscriptionsDbService } from '../../services/db/subscriptions-db-service.js';
-const mockSafeBatchQueryByGSI = DynamoDbClient.safeBatchQueryByGSI;
-const mockSafeQueryByGSI = DynamoDbClient.safeQueryByGSI;
-describe('SubscriptionsDbService', () => {
-    const TABLE_NAME = 'test-subscriptions-table';
-    const service = new SubscriptionsDbService(TABLE_NAME);
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe('batchGetByAccountIds', () => {
-        const INDEX_NAME = 'GSI_ACCOUNT_ID';
-        const ACCOUNT_ID_KEY = 'accountId';
-        it('returns empty array for empty accountIds input', async () => {
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, []);
-            expect(result).toEqual([]);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, [], 10);
-        });
-        it('returns subscriptions for single accountId', async () => {
-            const mockSubscription = {
-                id: 'sub-1',
-                accountId: 'acc-1',
-                plan: 'pro',
-            };
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([mockSubscription]);
-            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
-            expect(result).toEqual([mockSubscription]);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
-        });
-        it('returns subscriptions for multiple accountIds', async () => {
-            const mockSubscriptions = [
-                { id: 'sub-1', accountId: 'acc-1', plan: 'pro' },
-                { id: 'sub-2', accountId: 'acc-2', plan: 'starter' },
-                { id: 'sub-3', accountId: 'acc-2', plan: 'addon' },
-            ];
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce(mockSubscriptions);
-            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2']);
-            expect(result).toEqual(mockSubscriptions);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2'], 10);
-        });
-        it('uses custom concurrency parameter', async () => {
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
-        });
-        it('calls safeBatchQueryByGSI with correct table name from constructor', async () => {
-            const customService = new SubscriptionsDbService('custom-table');
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            await customService.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith('custom-table', INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
-        });
-    });
-    describe('getSubscriptionByAccountId', () => {
-        it('returns first subscription when found', async () => {
-            const mockSubscriptions = [
-                { id: 'sub-1', accountId: 'acc-1' },
-                { id: 'sub-2', accountId: 'acc-1' },
-            ];
-            mockSafeQueryByGSI.mockResolvedValueOnce(mockSubscriptions);
-            const result = await service.getSubscriptionByAccountId('GSI', 'accountId', 'acc-1');
-            expect(result).toEqual({ id: 'sub-1', accountId: 'acc-1' });
-        });
-        it('returns null when no subscriptions found', async () => {
-            mockSafeQueryByGSI.mockResolvedValueOnce([]);
-            const result = await service.getSubscriptionByAccountId('GSI', 'accountId', 'acc-1');
-            expect(result).toBeNull();
-        });
-        it('returns null when query returns null', async () => {
-            mockSafeQueryByGSI.mockResolvedValueOnce(null);
-            const result = await service.getSubscriptionByAccountId('GSI', 'accountId', 'acc-1');
-            expect(result).toBeNull();
-        });
-    });
-});
+jest.mock('../../clients/generic/dynamodb-client.js', () => ({
+    DynamoDbClient: {
+        safeGet: jest.fn(),
+        safeQueryByGSI: jest.fn(),
+        safeBatchQueryByGSI: jest.fn(),
+    },
+}));
+jest.mock('../../helpers/index.js', () => ({
+    Logger: {
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn(),
+    },
+}));
+import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
+import { SubscriptionsDbService } from '../../services/db/subscriptions-db-service.js';
+const mockSafeBatchQueryByGSI = DynamoDbClient.safeBatchQueryByGSI;
+const mockSafeQueryByGSI = DynamoDbClient.safeQueryByGSI;
+describe('SubscriptionsDbService', () => {
+    const TABLE_NAME = 'test-subscriptions-table';
+    const service = new SubscriptionsDbService(TABLE_NAME);
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('batchGetByAccountIds', () => {
+        const INDEX_NAME = 'GSI_ACCOUNT_ID';
+        const ACCOUNT_ID_KEY = 'accountId';
+        it('returns empty array for empty accountIds input', async () => {
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, []);
+            expect(result).toEqual([]);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, [], 10);
+        });
+        it('returns subscriptions for single accountId', async () => {
+            const mockSubscription = {
+                id: 'sub-1',
+                accountId: 'acc-1',
+                plan: 'pro',
+            };
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([mockSubscription]);
+            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
+            expect(result).toEqual([mockSubscription]);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
+        });
+        it('returns subscriptions for multiple accountIds', async () => {
+            const mockSubscriptions = [
+                { id: 'sub-1', accountId: 'acc-1', plan: 'pro' },
+                { id: 'sub-2', accountId: 'acc-2', plan: 'starter' },
+                { id: 'sub-3', accountId: 'acc-2', plan: 'addon' },
+            ];
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce(mockSubscriptions);
+            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2']);
+            expect(result).toEqual(mockSubscriptions);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2'], 10);
+        });
+        it('uses custom concurrency parameter', async () => {
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
+        });
+        it('calls safeBatchQueryByGSI with correct table name from constructor', async () => {
+            const customService = new SubscriptionsDbService('custom-table');
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            await customService.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith('custom-table', INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
+        });
+    });
+    describe('getSubscriptionByAccountId', () => {
+        it('returns first subscription when found', async () => {
+            const mockSubscriptions = [
+                { id: 'sub-1', accountId: 'acc-1' },
+                { id: 'sub-2', accountId: 'acc-1' },
+            ];
+            mockSafeQueryByGSI.mockResolvedValueOnce(mockSubscriptions);
+            const result = await service.getSubscriptionByAccountId('GSI', 'accountId', 'acc-1');
+            expect(result).toEqual({ id: 'sub-1', accountId: 'acc-1' });
+        });
+        it('returns null when no subscriptions found', async () => {
+            mockSafeQueryByGSI.mockResolvedValueOnce([]);
+            const result = await service.getSubscriptionByAccountId('GSI', 'accountId', 'acc-1');
+            expect(result).toBeNull();
+        });
+        it('returns null when query returns null', async () => {
+            mockSafeQueryByGSI.mockResolvedValueOnce(null);
+            const result = await service.getSubscriptionByAccountId('GSI', 'accountId', 'acc-1');
+            expect(result).toBeNull();
+        });
+    });
+});
 //# sourceMappingURL=subscriptions-db-service.spec.js.map

package/dist/esm/__tests__/db/user-accounts-db-service.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/__tests__/db/user-accounts-db-service.spec.js

@@ -1,75 +1,75 @@
-jest.mock('../../clients/generic/dynamodb-client.js', () => ({
-    DynamoDbClient: {
-        safeBatchQueryByGSI: jest.fn(),
-    },
-}));
-import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
-import { UserAccountsDbService } from '../../services/db/user-accounts-db-service.js';
-const mockSafeBatchQueryByGSI = DynamoDbClient.safeBatchQueryByGSI;
-describe('UserAccountsDbService', () => {
-    const TABLE_NAME = 'test-user-accounts-table';
-    const service = new UserAccountsDbService(TABLE_NAME);
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe('batchGetByAccountIds', () => {
-        const INDEX_NAME = 'GSI_ACCOUNT_ID';
-        const ACCOUNT_ID_KEY = 'accountId';
-        it('returns empty array for empty accountIds input', async () => {
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, []);
-            expect(result).toEqual([]);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, [], 10);
-        });
-        it('returns user-account records for single accountId', async () => {
-            const mockRecord = {
-                userId: 'user-1',
-                accountId: 'acc-1',
-                role: 'admin',
-            };
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([mockRecord]);
-            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
-            expect(result).toEqual([mockRecord]);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
-        });
-        it('returns user-account records for multiple accountIds', async () => {
-            const mockRecords = [
-                { userId: 'user-1', accountId: 'acc-1', role: 'admin' },
-                { userId: 'user-2', accountId: 'acc-1', role: 'member' },
-                { userId: 'user-3', accountId: 'acc-2', role: 'owner' },
-            ];
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce(mockRecords);
-            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2']);
-            expect(result).toEqual(mockRecords);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2'], 10);
-        });
-        it('uses custom concurrency parameter', async () => {
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
-        });
-        it('uses default concurrency of 10', async () => {
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2', 'acc-3']);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2', 'acc-3'], 10);
-        });
-        it('calls safeBatchQueryByGSI with correct table name from constructor', async () => {
-            const customService = new UserAccountsDbService('custom-table');
-            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
-            await customService.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
-            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith('custom-table', INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
-        });
-        it('uses default table key "userId" when not specified', async () => {
-            const defaultKeyService = new UserAccountsDbService('another-table');
-            expect(defaultKeyService.TABLE_KEY).toBe('userId');
-        });
-        it('uses custom table key when specified', async () => {
-            const customKeyService = new UserAccountsDbService('another-table', 'customKey');
-            expect(customKeyService.TABLE_KEY).toBe('customKey');
-        });
-    });
-});
+jest.mock('../../clients/generic/dynamodb-client.js', () => ({
+    DynamoDbClient: {
+        safeBatchQueryByGSI: jest.fn(),
+    },
+}));
+import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
+import { UserAccountsDbService } from '../../services/db/user-accounts-db-service.js';
+const mockSafeBatchQueryByGSI = DynamoDbClient.safeBatchQueryByGSI;
+describe('UserAccountsDbService', () => {
+    const TABLE_NAME = 'test-user-accounts-table';
+    const service = new UserAccountsDbService(TABLE_NAME);
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('batchGetByAccountIds', () => {
+        const INDEX_NAME = 'GSI_ACCOUNT_ID';
+        const ACCOUNT_ID_KEY = 'accountId';
+        it('returns empty array for empty accountIds input', async () => {
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, []);
+            expect(result).toEqual([]);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, [], 10);
+        });
+        it('returns user-account records for single accountId', async () => {
+            const mockRecord = {
+                userId: 'user-1',
+                accountId: 'acc-1',
+                role: 'admin',
+            };
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([mockRecord]);
+            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
+            expect(result).toEqual([mockRecord]);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
+        });
+        it('returns user-account records for multiple accountIds', async () => {
+            const mockRecords = [
+                { userId: 'user-1', accountId: 'acc-1', role: 'admin' },
+                { userId: 'user-2', accountId: 'acc-1', role: 'member' },
+                { userId: 'user-3', accountId: 'acc-2', role: 'owner' },
+            ];
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce(mockRecords);
+            const result = await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2']);
+            expect(result).toEqual(mockRecords);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2'], 10);
+        });
+        it('uses custom concurrency parameter', async () => {
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 5);
+        });
+        it('uses default concurrency of 10', async () => {
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            await service.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2', 'acc-3']);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith(TABLE_NAME, INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1', 'acc-2', 'acc-3'], 10);
+        });
+        it('calls safeBatchQueryByGSI with correct table name from constructor', async () => {
+            const customService = new UserAccountsDbService('custom-table');
+            mockSafeBatchQueryByGSI.mockResolvedValueOnce([]);
+            await customService.batchGetByAccountIds(INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1']);
+            expect(mockSafeBatchQueryByGSI).toHaveBeenCalledWith('custom-table', INDEX_NAME, ACCOUNT_ID_KEY, ['acc-1'], 10);
+        });
+        it('uses default table key "userId" when not specified', async () => {
+            const defaultKeyService = new UserAccountsDbService('another-table');
+            expect(defaultKeyService.TABLE_KEY).toBe('userId');
+        });
+        it('uses custom table key when specified', async () => {
+            const customKeyService = new UserAccountsDbService('another-table', 'customKey');
+            expect(customKeyService.TABLE_KEY).toBe('customKey');
+        });
+    });
+});
 //# sourceMappingURL=user-accounts-db-service.spec.js.map

package/dist/esm/__tests__/helpers/account-users-helper.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};