@adobe/spacecat-shared-tier-client 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [@adobe/spacecat-shared-tier-client-v1.1.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.0.1...@adobe/spacecat-shared-tier-client-v1.1.0) (2025-09-22)
+
+
+### Features
+
+* entitlement with out site and upgrade ([#971](https://github.com/adobe/spacecat-shared/issues/971)) ([1f042df](https://github.com/adobe/spacecat-shared/commit/1f042df62439383ff4a7cea6b0eb75649439e72a))
+
 # [@adobe/spacecat-shared-tier-client-v1.0.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tier-client-v1.0.0...@adobe/spacecat-shared-tier-client-v1.0.1) (2025-09-18)
 
 

package/package.json

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

package/src/tier-client.js

@@ -149,9 +149,10 @@ class TierClient {
 
   /**
    * Creates entitlement for organization and site enrollment for site.
-   * First validates that org and site don't already have an entitlement for this product.
+   * If entitlement exists with different tier, updates the tier.
    * @param {string} tier - Entitlement tier.
-   * @returns {Promise<object>} Object with created entitlement and siteEnrollment.
+   * @returns {Promise<object>} Object with created/updated
+   * entitlement and siteEnrollment (if site provided).
    */
   async createEntitlement(tier) {
     try {
@@ -159,42 +160,41 @@ class TierClient {
         throw new Error(`Invalid tier: ${tier}. Valid tiers: ${Object.values(EntitlementModel.TIERS).join(', ')}`);
       }
 
-      if (!this.site) {
-        throw new Error('Site required for creating entitlements');
-      }
-
       const orgId = this.organization.getId();
-      const siteId = this.site.getId();
-      this.log.info(`Creating entitlement for org ${orgId}, site ${siteId}, product ${this.productCode}, tier ${tier}`);
+      this.log.info(`Creating/updating entitlement for org ${orgId}, product ${this.productCode}, tier ${tier}`);
 
       // Check what already exists
       const existing = await this.checkValidEntitlement();
 
-      // If both entitlement and site enrollment exist, return them
-      if (existing.entitlement && existing.siteEnrollment) {
-        this.log.info(`Entitlement and site enrollment already exist for org ${orgId}, site ${siteId} and product ${this.productCode}`);
-        return existing;
-      }
-
-      // If only entitlement exists, we need to create site enrollment
-      if (existing.entitlement && !existing.siteEnrollment) {
-        this.log.info(`Entitlement exists but site enrollment missing for org ${orgId}, site ${siteId} and product ${this.productCode}`);
+      // If entitlement exists, handle tier update and return
+      if (existing.entitlement) {
+        const currentTier = existing.entitlement.getTier();
 
-        // Create site enrollment for existing entitlement
-        const siteEnrollment = await this.SiteEnrollment.create({
-          siteId,
-          entitlementId: existing.entitlement.getId(),
-        });
+        // If tier doesn't match, update it
+        if (currentTier !== tier) {
+          this.log.info(`Updating entitlement tier from ${currentTier} to ${tier} for org ${orgId}`);
+          existing.entitlement.setTier(tier);
+          await existing.entitlement.save();
+        }
 
-        this.log.info(`Created site enrollment: ${siteEnrollment.getId()}`);
+        // If site provided but no site enrollment, create it
+        if (this.site && !existing.siteEnrollment) {
+          const siteId = this.site.getId();
+          const siteEnrollment = await this.SiteEnrollment.create({
+            siteId,
+            entitlementId: existing.entitlement.getId(),
+          });
+          this.log.info(`Created site enrollment: ${siteEnrollment.getId()}`);
+          return {
+            entitlement: existing.entitlement,
+            siteEnrollment,
+          };
+        }
 
-        return {
-          entitlement: existing.entitlement,
-          siteEnrollment,
-        };
+        return existing;
       }
 
-      // Create entitlement
+      // No existing entitlement, create new one
       const entitlement = await this.Entitlement.create({
         organizationId: orgId,
         productCode: this.productCode,
@@ -205,9 +205,15 @@ class TierClient {
         },
       });
 
-      this.log.info(`Created entitlement: ${entitlement.getId()}`);
+      this.log.info(`Created new entitlement: ${entitlement.getId()}`);
+
+      // If no site provided, return entitlement only
+      if (!this.site) {
+        return { entitlement };
+      }
 
       // Create site enrollment
+      const siteId = this.site.getId();
       const siteEnrollment = await this.SiteEnrollment.create({
         siteId,
         entitlementId: entitlement.getId(),
@@ -220,7 +226,7 @@ class TierClient {
         siteEnrollment,
       };
     } catch (error) {
-      this.log.error(`Error creating entitlement and site enrollment: ${error.message}`);
+      this.log.error(`Error creating/updating entitlement: ${error.message}`);
       throw error;
     }
   }

package/test/tier-client.test.js

@@ -351,7 +351,7 @@ describe('TierClient', () => {
       await expect(tierClient.createEntitlement('INVALID_TIER')).to.be.rejectedWith('Invalid tier: INVALID_TIER');
     });
 
-    it('should throw error when site is not provided for createEntitlement', async () => {
+    it('should work without site for createEntitlement (organization only)', async () => {
       // Create a TierClient without site
       const tierClientWithoutSite = new TierClient(
         mockContext,
@@ -360,7 +360,64 @@ describe('TierClient', () => {
         productCode,
       );
 
-      await expect(tierClientWithoutSite.createEntitlement('FREE_TRIAL')).to.be.rejectedWith('Site required for creating entitlements');
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(null);
+      mockDataAccess.Entitlement.create.resolves(mockEntitlement);
+
+      const result = await tierClientWithoutSite.createEntitlement('FREE_TRIAL');
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+      });
+      expect(mockDataAccess.Entitlement.create).to.have.been.calledWith({
+        organizationId: orgId,
+        productCode,
+        tier: 'FREE_TRIAL',
+        quotas: { llmo_trial_prompts: 200, llmo_trial_prompts_consumed: 0 },
+      });
+      expect(mockDataAccess.SiteEnrollment.create).to.not.have.been.called;
+    });
+
+    it('should return existing entitlement when site is not provided and entitlement exists', async () => {
+      // Create a TierClient without site
+      const tierClientWithoutSite = new TierClient(
+        mockContext,
+        organizationInstance,
+        null,
+        productCode,
+      );
+
+      mockDataAccess.Entitlement.findByOrganizationIdAndProductCode.resolves(mockEntitlement);
+
+      const result = await tierClientWithoutSite.createEntitlement('FREE_TRIAL');
+
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlement,
+      });
+      expect(mockDataAccess.Entitlement.create).to.not.have.been.called;
+      expect(mockDataAccess.SiteEnrollment.create).to.not.have.been.called;
+    });
+
+    it('should update tier when entitlement exists with different tier', async () => {
+      const mockEntitlementWithDifferentTier = {
+        ...mockEntitlement,
+        getTier: () => 'PAID',
+        setTier: sandbox.stub().returnsThis(),
+        save: sandbox.stub().resolves(),
+      };
+
+      mockDataAccess.Entitlement
+        .findByOrganizationIdAndProductCode.resolves(mockEntitlementWithDifferentTier);
+      mockDataAccess.SiteEnrollment.allBySiteId.resolves([mockSiteEnrollment]);
+
+      const result = await tierClient.createEntitlement('FREE_TRIAL');
+
+      expect(mockEntitlementWithDifferentTier.setTier).to.have.been.calledWith('FREE_TRIAL');
+      expect(mockEntitlementWithDifferentTier.save).to.have.been.called;
+      expect(result).to.deep.equal({
+        entitlement: mockEntitlementWithDifferentTier,
+        siteEnrollment: mockSiteEnrollment,
+      });
+      expect(mockDataAccess.Entitlement.create).to.not.have.been.called;
     });
 
     it('should throw error when organization not found', async () => {