@adobe/spacecat-shared-tier-client 1.2.4 → 1.2.5

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [@adobe/spacecat-shared-tier-client-v1.2.5](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.2.4...@adobe/spacecat-shared-tier-client-v1.2.5) (2025-11-18)
+
+
+### Bug Fixes
+
+* adds getAllEnrollment and getFirstEnrolllment for tier client ([#1138](https://github.com/adobe/spacecat-shared/issues/1138)) ([ee8a834](https://github.com/adobe/spacecat-shared/commit/ee8a83414f49887009cad228bdba7d6c7376fe8d))
+
 # [@adobe/spacecat-shared-tier-client-v1.2.4](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.2.3...@adobe/spacecat-shared-tier-client-v1.2.4) (2025-11-15)
 
 

package/package.json

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

package/src/tier-client.js

@@ -220,6 +220,71 @@ class TierClient {
       throw new Error('Site enrollment not found');
     }
   }
+
+  /**
+   * Gets all enrollments based on context, filtered by productCode.
+   * - If site is provided: returns site enrollment for the entitlement matching productCode
+   * - If org-only: returns all site enrollments for the entitlement matching productCode
+   * @returns {Promise<object>} Object with entitlement and enrollments array.
+   */
+  async getAllEnrollment() {
+    try {
+      const orgId = this.organization.getId();
+      const entitlement = await this.Entitlement
+        .findByOrganizationIdAndProductCode(orgId, this.productCode);
+
+      if (!entitlement) {
+        return { entitlement: null, enrollments: [] };
+      }
+
+      const allEnrollments = await this.SiteEnrollment.allByEntitlementId(entitlement.getId());
+
+      if (this.site) {
+        // Return site enrollments matching the entitlement and site
+        const siteId = this.site.getId();
+        const matchingEnrollments = allEnrollments.filter(
+          (se) => se.getSiteId() === siteId,
+        );
+        return { entitlement, enrollments: matchingEnrollments };
+      } else {
+        // Return all enrollments for the entitlement
+        return { entitlement, enrollments: allEnrollments };
+      }
+    } catch (error) {
+      this.log.error(`Error getting all enrollments: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * 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
+   * @returns {Promise<object>} Object with entitlement, enrollment, and site.
+   */
+  async getFirstEnrollment() {
+    try {
+      const { entitlement, enrollments } = await this.getAllEnrollment();
+
+      if (!entitlement || !enrollments?.length) {
+        return { entitlement: null, enrollment: null, site: null };
+      }
+
+      const firstEnrollment = enrollments[0];
+      const enrollmentSiteId = firstEnrollment.getSiteId();
+      const site = await this.Site.findById(enrollmentSiteId);
+
+      if (!site) {
+        this.log.warn(`Site not found for enrollment ${firstEnrollment.getId()} with site ID ${enrollmentSiteId}`);
+        return { entitlement, enrollment: firstEnrollment, site: null };
+      }
+
+      return { entitlement, enrollment: firstEnrollment, site };
+    } catch (error) {
+      this.log.error(`Error getting first enrollment: ${error.message}`);
+      throw error;
+    }
+  }
 }
 
 export default TierClient;

package/test/tier-client.test.js

@@ -86,6 +86,7 @@ describe('TierClient', () => {
       info: sandbox.stub(),
       error: sandbox.stub(),
       debug: sandbox.stub(),
+      warn: sandbox.stub(),
     },
     attributes: {
       authInfo: {
@@ -543,4 +544,272 @@ describe('TierClient', () => {
       await expect(orgOnlyClient.revokeSiteEnrollment()).to.be.rejectedWith('Site enrollment not found');
     });
   });
+
+  describe('getAllEnrollment', () => {
+    beforeEach(() => {
+      mockDataAccess.SiteEnrollment.allByEntitlementId = sandbox.stub();
+    });
+
+    it('should return entitlement and enrollments when both exist (org-only)', async () => {
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      const mockEnrollment2 = {
+        getId: () => 'enrollment-456',
+        getSiteId: () => '789-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
+        mockSiteEnrollment,
+        mockEnrollment2,
+      ]);
+
+      const result = await tierClientWithoutSite.getAllEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollments: [mockSiteEnrollment, mockEnrollment2],
+      });
+      expect(mockDataAccess.Entitlement.findByOrganizationIdAndProductCode)
+        .to.have.been.calledWith(orgId, productCode);
+      expect(mockDataAccess.SiteEnrollment.allByEntitlementId)
+        .to.have.been.calledWith('entitlement-123');
+    });
+
+    it('should return filtered enrollments when site is provided', async () => {
+      const mockEnrollment2 = {
+        getId: () => 'enrollment-456',
+        getSiteId: () => 'other-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
+        mockSiteEnrollment,
+        mockEnrollment2,
+      ]);
+
+      const result = await tierClient.getAllEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollments: [mockSiteEnrollment],
+      });
+      expect(mockDataAccess.SiteEnrollment.allByEntitlementId)
+        .to.have.been.calledWith('entitlement-123');
+    });
+
+    it('should return null entitlement and empty enrollments when no entitlement exists', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(null);
+
+      const result = await tierClient.getAllEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: null,
+        enrollments: [],
+      });
+      expect(mockDataAccess.SiteEnrollment.allByEntitlementId).to.not.have.been.called;
+    });
+
+    it('should return empty enrollments when entitlement exists but no enrollments', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([]);
+
+      const result = await tierClient.getAllEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollments: [],
+      });
+    });
+
+    it('should handle database errors', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.rejects(new Error('Database error'));
+
+      await expect(tierClient.getAllEnrollment()).to.be.rejectedWith('Database error');
+      expect(mockContext.log.error).to.have.been.calledWith('Error getting all enrollments: Database error');
+    });
+
+    it('should filter out enrollments not matching site ID', async () => {
+      const mockEnrollment2 = {
+        getId: () => 'enrollment-456',
+        getSiteId: () => 'different-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      const mockEnrollment3 = {
+        getId: () => 'enrollment-789',
+        getSiteId: () => siteId,
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
+        mockSiteEnrollment,
+        mockEnrollment2,
+        mockEnrollment3,
+      ]);
+
+      const result = await tierClient.getAllEnrollment();
+
+      expect(result.enrollments).to.have.lengthOf(2);
+      expect(result.enrollments).to.deep.equal([mockSiteEnrollment, mockEnrollment3]);
+    });
+  });
+
+  describe('getFirstEnrollment', () => {
+    beforeEach(() => {
+      mockDataAccess.SiteEnrollment.allByEntitlementId = sandbox.stub();
+    });
+
+    it('should return entitlement, first enrollment, and site when all exist', async () => {
+      const mockSiteObject = {
+        getId: () => siteId,
+        getName: () => 'Test Site',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
+      mockDataAccess.Site.findById.resolves(mockSiteObject);
+
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      const result = await tierClientWithoutSite.getFirstEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollment: mockSiteEnrollment,
+        site: mockSiteObject,
+      });
+      expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
+    });
+
+    it('should return first enrollment when multiple exist', async () => {
+      const mockSiteObject = {
+        getId: () => siteId,
+        getName: () => 'Test Site',
+      };
+
+      const mockEnrollment2 = {
+        getId: () => 'enrollment-456',
+        getSiteId: () => 'other-site-id',
+        getEntitlementId: () => 'entitlement-123',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([
+        mockSiteEnrollment,
+        mockEnrollment2,
+      ]);
+      mockDataAccess.Site.findById.resolves(mockSiteObject);
+
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      const result = await tierClientWithoutSite.getFirstEnrollment();
+
+      expect(result.enrollment).to.equal(mockSiteEnrollment);
+      expect(mockDataAccess.Site.findById).to.have.been.calledWith(siteId);
+    });
+
+    it('should return nulls when no entitlement exists', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(null);
+
+      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 return nulls when no enrollments exist', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([]);
+
+      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 return null site when site not found in database', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
+      mockDataAccess.Site.findById.resolves(null);
+
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      const result = await tierClientWithoutSite.getFirstEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollment: mockSiteEnrollment,
+        site: null,
+      });
+      expect(mockContext.log.warn).to.have.been.calledWith(
+        `Site not found for enrollment ${mockSiteEnrollment.getId()} with site ID ${siteId}`,
+      );
+    });
+
+    it('should handle database errors', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.rejects(new Error('Database error'));
+
+      await expect(tierClient.getFirstEnrollment()).to.be.rejectedWith('Database error');
+      expect(mockContext.log.error).to.have.been.calledWith('Error getting first enrollment: Database error');
+    });
+
+    it('should work with site-specific client', async () => {
+      const mockSiteObject = {
+        getId: () => siteId,
+        getName: () => 'Test Site',
+      };
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
+      mockDataAccess.Site.findById.resolves(mockSiteObject);
+
+      const result = await tierClient.getFirstEnrollment();
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+        enrollment: mockSiteEnrollment,
+        site: mockSiteObject,
+      });
+    });
+
+    it('should handle error when fetching site', async () => {
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+      mockDataAccess.SiteEnrollment.allByEntitlementId.resolves([mockSiteEnrollment]);
+      mockDataAccess.Site.findById.rejects(new Error('Site fetch error'));
+
+      await expect(tierClient.getFirstEnrollment()).to.be.rejectedWith('Site fetch error');
+    });
+  });
 });