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

package/.releaserc.cjs

@@ -1,8 +1,12 @@
 module.exports = {
   extends: "semantic-release-monorepo",
   plugins: [
-    "@semantic-release/commit-analyzer",
-    "@semantic-release/release-notes-generator",
+    ["@semantic-release/commit-analyzer", {
+      "preset": "conventionalcommits",
+    }],
+    ["@semantic-release/release-notes-generator", {
+      "preset": "conventionalcommits",
+    }],
     ["@semantic-release/changelog", {
       "changelogFile": "CHANGELOG.md",
     }],

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [@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
+
+* **data-access:** decouple shared packages for v2/v3 alias wrapper rollout ([#1355](https://github.com/adobe/spacecat-shared/issues/1355)) ([ba48df7](https://github.com/adobe/spacecat-shared/commit/ba48df710e0030c1cb3ef4f90661cff1b548d42f))
+
 # [@adobe/spacecat-shared-tier-client-v1.3.11](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.3.10...@adobe/spacecat-shared-tier-client-v1.3.11) (2026-02-06)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-tier-client",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "description": "Shared modules of the Spacecat Services - Tier Client",
   "type": "module",
   "engines": {
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@adobe/spacecat-shared-utils": "1.81.1",
-    "@adobe/spacecat-shared-data-access": "2.88.7"
+    "@mysticat/data-service-types": "git+https://github.com/adobe/mysticat-data-service.git#types-ts-v1.11.1"
   },
   "devDependencies": {
     "c8": "10.1.3",

package/src/tier-client.js

@@ -11,9 +11,9 @@
  */
 
 import { isNonEmptyObject, hasText } from '@adobe/spacecat-shared-utils';
-import {
-  Entitlement as EntitlementModel,
-} from '@adobe/spacecat-shared-data-access';
+import { MYSTICAT_ENUMS_BY_TYPE } from '@mysticat/data-service-types';
+
+const ENTITLEMENT_TIERS = MYSTICAT_ENUMS_BY_TYPE.ENTITLEMENT_TIER;
 /**
  * TierClient provides methods to manage entitlements and site enrollments.
  */
@@ -137,8 +137,8 @@ class TierClient {
    */
   async createEntitlement(tier) {
     try {
-      if (!Object.values(EntitlementModel.TIERS).includes(tier)) {
-        throw new Error(`Invalid tier: ${tier}. Valid tiers: ${Object.values(EntitlementModel.TIERS).join(', ')}`);
+      if (!Object.values(ENTITLEMENT_TIERS).includes(tier)) {
+        throw new Error(`Invalid tier: ${tier}. Valid tiers: ${Object.values(ENTITLEMENT_TIERS).join(', ')}`);
       }
       const orgId = this.organization.getId();
       // Check what already exists
@@ -149,7 +149,7 @@ class TierClient {
         const currentTier = existing.entitlement.getTier();
 
         // If currentTier doesn't match with given tier and is not PAID, update it
-        if (currentTier !== tier && currentTier !== EntitlementModel.TIERS.PAID) {
+        if (currentTier !== tier && currentTier !== ENTITLEMENT_TIERS.PAID) {
           existing.entitlement.setTier(tier);
           await existing.entitlement.save();
         }
@@ -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 || !enrollments?.length) {
+      if (!entitlement) {
         return { entitlement: null, enrollment: null, site: null };
       }
 
-      const firstEnrollment = enrollments[0];
-      const enrollmentSiteId = firstEnrollment.getSiteId();
-      const site = await this.Site.findById(enrollmentSiteId);
+      const allEnrollments = await this.SiteEnrollment.allByEntitlementId(entitlement.getId());
 
-      if (!site) {
-        this.log.warn(`Site not found for enrollment ${firstEnrollment.getId()} with site ID ${enrollmentSiteId}`);
-        return { entitlement, enrollment: firstEnrollment, site: null };
+      if (!allEnrollments || allEnrollments.length === 0) {
+        return { entitlement: null, enrollment: null, site: null };
+      }
+
+      // 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 };
+      }
+
+      // 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;
@@ -314,7 +353,7 @@ class TierClient {
   async revokeEntitlement() {
     const existing = await this.checkValidEntitlement();
     if (existing.entitlement) {
-      if (existing.entitlement.getTier() === EntitlementModel.TIERS.PAID) {
+      if (existing.entitlement.getTier() === ENTITLEMENT_TIERS.PAID) {
         throw new Error('Paid entitlement cannot be revoked');
       }
       await existing.entitlement.remove();

package/test/tier-client.test.js

@@ -17,7 +17,6 @@ import chaiAsPromised from 'chai-as-promised';
 import sinonChai from 'sinon-chai';
 import sinon from 'sinon';
 
-import { Organization, Site } from '@adobe/spacecat-shared-data-access';
 import TierClient from '../src/tier-client.js';
 
 use(chaiAsPromised);
@@ -49,11 +48,7 @@ describe('TierClient', () => {
   };
 
   // Create actual Organization instance for instanceof checks
-  const organizationInstance = Object.create(Organization.prototype);
-  Object.assign(
-    organizationInstance,
-    { entityName: Organization.ENTITY_NAME, ...mockOrganization },
-  );
+  const organizationInstance = { ...mockOrganization };
 
   const mockSite = {
     getId: () => siteId,
@@ -62,8 +57,7 @@ describe('TierClient', () => {
   };
 
   // Create actual Site instance for instanceof checks
-  const siteInstance = Object.create(Site.prototype);
-  Object.assign(siteInstance, { entityName: Site.ENTITY_NAME, ...mockSite });
+  const siteInstance = { ...mockSite };
 
   const mockDataAccess = {
     Entitlement: {
@@ -121,23 +115,18 @@ describe('TierClient', () => {
   });
 
   describe('Static Factory Methods', () => {
-    const testOrganization = Object.create(Organization.prototype);
-    Object.assign(testOrganization, { entityName: Organization.ENTITY_NAME, getId: () => orgId });
+    const testOrganization = { getId: () => orgId };
 
-    const testSite = Object.create(Site.prototype);
-    Object.assign(testSite, {
-      entityName: Site.ENTITY_NAME,
+    const testSite = {
       getId: () => siteId,
       getOrganizationId: () => orgId,
       getOrganization: () => testOrganization,
-    });
+    };
 
-    const testSiteWithOrgRef = Object.create(Site.prototype);
-    Object.assign(testSiteWithOrgRef, {
-      entityName: Site.ENTITY_NAME,
+    const testSiteWithOrgRef = {
       getId: () => siteId,
       getOrganizationId: () => orgId,
-    });
+    };
 
     describe('createForOrg', () => {
       it('should create TierClient for organization', () => {
@@ -775,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();
 
@@ -796,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 () => {
@@ -831,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',
@@ -849,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 () => {
@@ -950,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(
@@ -971,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 () => {
@@ -980,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',
@@ -997,10 +995,6 @@ describe('TierClient', () => {
         mockSiteEnrollment,
         mockEnrollment2,
       ]);
-      mockDataAccess.Site.batchGetByKeys.resolves({
-        data: [mockSiteObject, mockSiteObject2],
-        unprocessed: [],
-      });
       mockDataAccess.Site.findById.resolves(mockSiteObject);
 
       const tierClientWithoutSite = new TierClient(
@@ -1013,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 () => {
@@ -1043,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(
@@ -1068,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}`,
       );
     });
 
@@ -1085,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'));
 
-      await expect(tierClient.getFirstEnrollment()).to.be.rejectedWith('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();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollment: enrollment2,
+        site: correctSite,
+      });
+      expect(mockDataAccess.Site.findById).to.have.been.calledTwice;
     });
   });
 });