@adobe/spacecat-shared-tier-client 1.3.12 → 1.3.13

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [@adobe/spacecat-shared-tier-client-v1.3.13](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.3.12...@adobe/spacecat-shared-tier-client-v1.3.13) (2026-03-01)
+
+### Bug Fixes
+
+* **tier-client:** avoid 414 URI Too Large on orgs with many enrollments ([#1390](https://github.com/adobe/spacecat-shared/issues/1390)) ([2e9de5e](https://github.com/adobe/spacecat-shared/commit/2e9de5e685c2a25801d4d50ad7317773ee706ef0))
+
 ## [@adobe/spacecat-shared-tier-client-v1.3.12](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.3.11...@adobe/spacecat-shared-tier-client-v1.3.12) (2026-02-17)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-tier-client",
-  "version": "1.3.12",
+  "version": "1.3.13",
   "description": "Shared modules of the Spacecat Services - Tier Client",
   "type": "module",
   "engines": {

package/src/tier-client.js

@@ -239,10 +239,40 @@ class TierClient {
         return { entitlement, enrollments: [] };
       }
 
-      // Fetch all sites using batchGetByKeys
+      // When a specific site is provided, skip batch fetch entirely.
+      // Just filter enrollments by site ID and verify org ownership with a single lookup.
+      if (this.site) {
+        const targetSiteId = this.site.getId();
+        const matchingEnrollments = allEnrollments.filter(
+          (se) => se.getSiteId() === targetSiteId,
+        );
+
+        if (matchingEnrollments.length === 0) {
+          return { entitlement, enrollments: [] };
+        }
+
+        const site = await this.Site.findById(targetSiteId);
+        if (!site || site.getOrganizationId() !== orgId) {
+          return { entitlement, enrollments: [] };
+        }
+
+        return { entitlement, enrollments: matchingEnrollments };
+      }
+
+      // Org-only path: fetch sites in chunks to avoid 414 URI Too Large.
+      // PostgREST uses GET with ?id=in.(...) which has URL length limits.
+      const CHUNK_SIZE = 50;
       const siteKeys = allEnrollments.map((enrollment) => ({ siteId: enrollment.getSiteId() }));
-      const sitesResult = await this.Site.batchGetByKeys(siteKeys);
-      const sitesMap = new Map(sitesResult.data.map((site) => [site.getId(), site]));
+      const sitesMap = new Map();
+
+      for (let i = 0; i < siteKeys.length; i += CHUNK_SIZE) {
+        const chunk = siteKeys.slice(i, i + CHUNK_SIZE);
+        // eslint-disable-next-line no-await-in-loop
+        const sitesResult = await this.Site.batchGetByKeys(chunk);
+        for (const site of sitesResult.data) {
+          sitesMap.set(site.getId(), site);
+        }
+      }
 
       // Filter enrollments where site's orgId matches the entitlement's orgId
       const validEnrollments = [];
@@ -250,27 +280,13 @@ class TierClient {
       for (const enrollment of allEnrollments) {
         const site = sitesMap.get(enrollment.getSiteId());
         if (!site) {
-          // Site not found, log warning and skip
           this.log.warn(`Site not found for enrollment ${enrollment.getId()} with siteId ${enrollment.getSiteId()}`);
-        } else {
-          const siteOrgId = site.getOrganizationId();
-          if (siteOrgId === orgId) {
-            validEnrollments.push(enrollment);
-          }
+        } else if (site.getOrganizationId() === orgId) {
+          validEnrollments.push(enrollment);
         }
       }
 
-      if (this.site) {
-        // Return site enrollments matching the entitlement and site
-        const siteId = this.site.getId();
-        const matchingEnrollments = validEnrollments.filter(
-          (se) => se.getSiteId() === siteId,
-        );
-        return { entitlement, enrollments: matchingEnrollments };
-      } else {
-        // Return all valid enrollments for the entitlement
-        return { entitlement, enrollments: validEnrollments };
-      }
+      return { entitlement, enrollments: validEnrollments };
     } catch (error) {
       this.log.error(`Error getting all enrollments: ${error.message}`);
       throw error;
@@ -279,28 +295,51 @@ class TierClient {
 
   /**
    * Gets the first enrollment and its site, filtered by productCode.
-   * - If site is provided: returns site enrollment for the entitlement matching productCode
-   * - If org-only: returns first site enrollment for the entitlement matching productCode
+   * - If site is provided: finds matching enrollment and returns this.site directly
+   * - If org-only: iterates enrollments, fetches sites one at a time, returns first org match
    * @returns {Promise<object>} Object with entitlement, enrollment, and site.
    */
   async getFirstEnrollment() {
     try {
-      const { entitlement, enrollments } = await this.getAllEnrollment();
+      const orgId = this.organization.getId();
+      const entitlement = await this.Entitlement
+        .findByOrganizationIdAndProductCode(orgId, this.productCode);
+
+      if (!entitlement) {
+        return { entitlement: null, enrollment: null, site: null };
+      }
+
+      const allEnrollments = await this.SiteEnrollment.allByEntitlementId(entitlement.getId());
 
-      if (!entitlement || !enrollments?.length) {
+      if (!allEnrollments || allEnrollments.length === 0) {
         return { entitlement: null, enrollment: null, site: null };
       }
 
-      const firstEnrollment = enrollments[0];
-      const enrollmentSiteId = firstEnrollment.getSiteId();
-      const site = await this.Site.findById(enrollmentSiteId);
+      // When a specific site is set, find its enrollment in memory — no fetch needed.
+      if (this.site) {
+        const targetSiteId = this.site.getId();
+        const matchingEnrollment = allEnrollments.find(
+          (se) => se.getSiteId() === targetSiteId,
+        );
+        if (matchingEnrollment) {
+          return { entitlement, enrollment: matchingEnrollment, site: this.site };
+        }
+        return { entitlement: null, enrollment: null, site: null };
+      }
 
-      if (!site) {
-        this.log.warn(`Site not found for enrollment ${firstEnrollment.getId()} with site ID ${enrollmentSiteId}`);
-        return { entitlement, enrollment: firstEnrollment, site: null };
+      // Org-only: iterate enrollments, fetch site one at a time, return first org match.
+      // This avoids batch-fetching all sites (which causes 414 on large sets).
+      for (const enrollment of allEnrollments) {
+        // eslint-disable-next-line no-await-in-loop
+        const site = await this.Site.findById(enrollment.getSiteId());
+        if (!site) {
+          this.log.warn(`Site not found for enrollment ${enrollment.getId()} with siteId ${enrollment.getSiteId()}`);
+        } else if (site.getOrganizationId() === orgId) {
+          return { entitlement, enrollment, site };
+        }
       }
 
-      return { entitlement, enrollment: firstEnrollment, site };
+      return { entitlement: null, enrollment: null, site: null };
     } catch (error) {
       this.log.error(`Error getting first enrollment: ${error.message}`);
       throw error;

package/test/tier-client.test.js

@@ -764,20 +764,12 @@ describe('TierClient', () => {
         getOrganizationId: () => orgId,
       };
 
-      const mockSiteForEnrollment2 = {
-        getId: () => 'other-site-id',
-        getOrganizationId: () => orgId,
-      };
-
       mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
       mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
         mockSiteEnrollment,
         mockEnrollment2,
       ]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteForEnrollment1, mockSiteForEnrollment2],
-        unprocessed: [],
-      });
+      mockDataAccess.Site.findById.resolves(mockSiteForEnrollment1);
 
       const result = await tierClient.getAllEnrollment();
 
@@ -785,8 +777,8 @@ describe('TierClient', () => {
         entitlement: mockEntitlement,
         enrollments: [mockSiteEnrollment],
       });
-      expect(mockDataAccess.SiteEnrollment.allByEntitlementId)
-        .to.have.been.calledWith('entitlement-123');
+      expect(mockDataAccess.Site.batchGetByKeys).to.not.have.been.called;
+      expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
     });
 
     it('should return null entitlement and empty enrollments when no entitlement exists', async () => {
@@ -820,6 +812,38 @@ describe('TierClient', () => {
       expect(mockContext.log.error).to.have.been.calledWith('Error getting all enrollments: Database error');
     });
 
+    it('should return empty enrollments when site has no matching enrollments', async () => {
+      const nonMatchingEnrollment = {
+        getId: () => 'enrollment-999',
+        getSiteId: () => 'other-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([nonMatchingEnrollment]);
+
+      const result = await tierClient.getAllEnrollment();
+
+      expect(result).to.deep.equal({ entitlement: mockEntitlement, enrollments: [] });
+      expect(mockDataAccess.Site.findById).to.not.have.been.called;
+    });
+
+    it('should return empty enrollments when site org does not match', async () => {
+      const wrongOrgSite = {
+        getId: () => siteId,
+        getOrganizationId: () => 'wrong-org-id',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
+      mockDataAccess.Site.findById.resolves(wrongOrgSite);
+
+      const result = await tierClient.getAllEnrollment();
+
+      expect(result).to.deep.equal({ entitlement: mockEntitlement, enrollments: [] });
+      expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
+    });
+
     it('should filter out enrollments not matching site ID', async () => {
       const mockEnrollment2 = {
         getId: () => 'enrollment-456',
@@ -838,26 +862,20 @@ describe('TierClient', () => {
         getOrganizationId: () => orgId,
       };
 
-      const mockSiteForEnrollment2 = {
-        getId: () => 'different-site-id',
-        getOrganizationId: () => orgId,
-      };
-
       mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
       mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
         mockSiteEnrollment,
         mockEnrollment2,
         mockEnrollment3,
       ]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteForEnrollment1, mockSiteForEnrollment2, mockSiteForEnrollment1],
-        unprocessed: [],
-      });
+      mockDataAccess.Site.findById.resolves(mockSiteForEnrollment1);
 
       const result = await tierClient.getAllEnrollment();
 
       expect(result.enrollments).to.have.lengthOf(2);
       expect(result.enrollments).to.deep.equal([mockSiteEnrollment, mockEnrollment3]);
+      expect(mockDataAccess.Site.batchGetByKeys).to.not.have.been.called;
+      expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
     });
 
     it('should filter out enrollments with mismatching orgId', async () => {
@@ -939,10 +957,6 @@ describe('TierClient', () => {
 
       mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
       mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteObject],
-        unprocessed: [],
-      });
       mockDataAccess.Site.findById.resolves(mockSiteObject);
 
       const tierClientWithoutSite = new TierClient(
@@ -960,6 +974,7 @@ describe('TierClient', () => {
         site: mockSiteObject,
       });
       expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
+      expect(mockDataAccess.Site.batchGetByKeys).to.not.have.been.called;
     });
 
     it('should return first enrollment when multiple exist', async () => {
@@ -969,12 +984,6 @@ describe('TierClient', () => {
         getOrganizationId: () => orgId,
       };
 
-      const mockSiteObject2 = {
-        getId: () => 'other-site-id',
-        getName: () => 'Other Site',
-        getOrganizationId: () => orgId,
-      };
-
       const mockEnrollment2 = {
         getId: () => 'enrollment-456',
         getSiteId: () => 'other-site-id',
@@ -986,10 +995,6 @@ describe('TierClient', () => {
         mockSiteEnrollment,
         mockEnrollment2,
       ]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteObject, mockSiteObject2],
-        unprocessed: [],
-      });
       mockDataAccess.Site.findById.resolves(mockSiteObject);
 
       const tierClientWithoutSite = new TierClient(
@@ -1002,7 +1007,9 @@ describe('TierClient', () => {
       const result = await tierClientWithoutSite.getFirstEnrollment();
 
       expect(result.enrollment).to.equal(mockSiteEnrollment);
-      expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
+      expect(result.site).to.equal(mockSiteObject);
+      expect(mockDataAccess.Site.findById).to.have.been.calledOnceWith(siteId);
+      expect(mockDataAccess.Site.batchGetByKeys).to.not.have.been.called;
     });
 
     it('should return nulls when no entitlement exists', async () => {
@@ -1032,19 +1039,9 @@ describe('TierClient', () => {
       expect(mockDataAccess.Site.findById).to.not.have.been.called;
     });
 
-    it('should return null site when site not found in database', async () => {
-      const mockSiteObject = {
-        getId: () => siteId,
-        getName: () => 'Test Site',
-        getOrganizationId: () => orgId,
-      };
-
+    it('should skip enrollment when site not found and return nulls', async () => {
       mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
       mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteObject],
-        unprocessed: [],
-      });
       mockDataAccess.Site.findById.resolves(null);
 
       const tierClientWithoutSite = new TierClient(
@@ -1057,12 +1054,12 @@ describe('TierClient', () => {
       const result = await tierClientWithoutSite.getFirstEnrollment();
 
       expect(result).to.deep.equal({
-        entitlement: mockEntitlement,
-        enrollment: mockSiteEnrollment,
+        entitlement: null,
+        enrollment: null,
         site: null,
       });
       expect(mockContext.log.warn).to.have.been.calledWith(
-        `Site not found for enrollment ${mockSiteEnrollment.getId()} with site ID ${siteId}`,
+        `Site not found for enrollment ${mockSiteEnrollment.getId()} with siteId ${siteId}`,
       );
     });
 
@@ -1074,35 +1071,96 @@ describe('TierClient', () => {
     });
 
     it('should work with site-specific client', async () => {
-      const mockSiteObject = {
-        getId: () => siteId,
-        getName: () => 'Test Site',
-        getOrganizationId: () => orgId,
-      };
-
       mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
       mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteObject],
-        unprocessed: [],
-      });
-      mockDataAccess.Site.findById.resolves(mockSiteObject);
 
       const result = await tierClient.getFirstEnrollment();
 
       expect(result).to.deep.equal({
         entitlement: mockEntitlement,
         enrollment: mockSiteEnrollment,
-        site: mockSiteObject,
+        site: siteInstance,
       });
+      expect(mockDataAccess.Site.findById).to.not.have.been.called;
+      expect(mockDataAccess.Site.batchGetByKeys).to.not.have.been.called;
     });
 
-    it('should handle error when fetching site via batchGetByKeys', async () => {
+    it('should handle error when fetching site via findById', async () => {
       mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
       mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
-      mockDataAccess.Site.batchGetByKeys.rejects(new Error('Site fetch error'));
+      mockDataAccess.Site.findById.rejects(new Error('Site fetch error'));
+
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      await expect(tierClientWithoutSite.getFirstEnrollment()).to.be.rejectedWith('Site fetch error');
+      expect(mockDataAccess.Site.batchGetByKeys).to.not.have.been.called;
+    });
+
+    it('should return nulls when site-specific client has no matching enrollment', async () => {
+      const nonMatchingEnrollment = {
+        getId: () => 'enrollment-999',
+        getSiteId: () => 'other-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([nonMatchingEnrollment]);
+
+      const result = await tierClient.getFirstEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: null,
+        enrollment: null,
+        site: null,
+      });
+      expect(mockDataAccess.Site.findById).to.not.have.been.called;
+    });
+
+    it('should skip enrollments with mismatching orgId and return first match', async () => {
+      const wrongOrgSite = {
+        getId: () => siteId,
+        getOrganizationId: () => 'wrong-org-id',
+      };
+
+      const correctSite = {
+        getId: () => 'correct-site-id',
+        getOrganizationId: () => orgId,
+      };
+
+      const enrollment2 = {
+        getId: () => 'enrollment-456',
+        getSiteId: () => 'correct-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
+        mockSiteEnrollment,
+        enrollment2,
+      ]);
+      mockDataAccess.Site.findById.onFirstCall().resolves(wrongOrgSite);
+      mockDataAccess.Site.findById.onSecondCall().resolves(correctSite);
+
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      const result = await tierClientWithoutSite.getFirstEnrollment();
 
-      await expect(tierClient.getFirstEnrollment()).to.be.rejectedWith('Site fetch error');
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollment: enrollment2,
+        site: correctSite,
+      });
+      expect(mockDataAccess.Site.findById).to.have.been.calledTwice;
     });
   });
 });