@frontegg/entitlements-javascript-commons 1.1.0-alpha.1 → 1.1.0-alpha.3

package/src/user-entitlements/is-entitled-to-feature/evaluators/feature-flag.evaluator.ts

@@ -0,0 +1,24 @@
+import { Attributes, EntitlementResult, NotEntitledJustification, UserEntitlementsContext } from '../../types';
+import { evaluateFeatureFlag } from '../../../feature-flags';
+import { prepareAttributes } from '../../utils/attributes.utils';
+import { TreatmentEnum } from '../../../rules';
+
+export function featureFlagEvaluator(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const feature = userEntitlementsContext.features[featureKey];
+  if (feature && feature.featureFlag) {
+    const preparedAttributes = prepareAttributes(attributes);
+    const { treatment } = evaluateFeatureFlag(feature.featureFlag, preparedAttributes);
+    if (treatment === TreatmentEnum.True) {
+      return { isEntitled: true };
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: NotEntitledJustification.MISSING_FEATURE,
+  };
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/index.ts

@@ -0,0 +1,8 @@
+import { directEntitlementEvalutor } from './direct-entitlement.evaluator';
+import { featureFlagEvaluator } from './feature-flag.evaluator';
+import { planTargetingRulesEvalutor } from './plan-targeting-rules.evaluator';
+import { IsEntitledEvaluator } from './types';
+
+export function getIsEntitledEvaluators(): IsEntitledEvaluator[] {
+  return [directEntitlementEvalutor, featureFlagEvaluator, planTargetingRulesEvalutor];
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/plan-targeting-rules.evaluator.ts

@@ -0,0 +1,30 @@
+import { Attributes, EntitlementResult, NotEntitledJustification, UserEntitlementsContext } from '../../types';
+import { prepareAttributes } from '../../utils/attributes.utils';
+import { TreatmentEnum } from '../../../rules';
+import { evaluatePlan } from '../../../plans';
+
+export function planTargetingRulesEvalutor(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const feature = userEntitlementsContext.features[featureKey];
+  if (feature && feature.planIds && feature.planIds.length > 0) {
+    const preparedAttributes = prepareAttributes(attributes);
+    const plans = userEntitlementsContext.plans;
+    for (const planId of feature.planIds) {
+      const plan = plans[planId];
+      if (plan) {
+        const { treatment } = evaluatePlan(plan, preparedAttributes);
+        if (treatment === TreatmentEnum.True) {
+          return { isEntitled: true };
+        }
+      }
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: NotEntitledJustification.MISSING_FEATURE,
+  };
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/tests/direct-entitlements.evaluator.spec.ts

@@ -0,0 +1,81 @@
+import { NO_EXPIRATION_TIME, NotEntitledJustification } from '../../../types';
+import { directEntitlementEvalutor } from '../direct-entitlement.evaluator';
+
+describe('directEntitlementEvalutor', () => {
+  describe('entitled', () => {
+    test('feature is entitled with no expiration date', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: NO_EXPIRATION_TIME,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+
+    test('feature is entitled with a valid expiration date', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: Date.now() + 3600,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('feature is not entitled', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+
+    test('feature is entitled with an expired expiration date', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: Date.now() - 3600,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+
+    test('feature does not exist', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-feature/evaluators/tests/feature-flag.evaluator.spec.ts

@@ -0,0 +1,57 @@
+import * as AttributesUtils from '../../../utils/attributes.utils';
+import * as FeatureFlagEvaluator from '../../../../feature-flags/feature-flag.evaluator';
+import { TreatmentEnum } from '../../../../rules';
+import { featureFlagEvaluator } from '../feature-flag.evaluator';
+import { NotEntitledJustification } from '../../../types';
+describe('featureFlagEvaluator', () => {
+  beforeAll(async () => {
+    jest.spyOn(AttributesUtils, 'prepareAttributes').mockReturnValue({ testAttribute: 'test-value' });
+  });
+  describe('entitled', () => {
+    test('feature flag evaluation return truthy', async () => {
+      jest.spyOn(FeatureFlagEvaluator, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.True });
+      const result = featureFlagEvaluator('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: [],
+            featureFlag: { defaultTreatment: TreatmentEnum.True, on: true, offTreatment: TreatmentEnum.False },
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('feature flag evaluation return falsy', async () => {
+      jest.spyOn(FeatureFlagEvaluator, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.False });
+      const result = featureFlagEvaluator('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: [],
+            featureFlag: { defaultTreatment: TreatmentEnum.False, on: true, offTreatment: TreatmentEnum.False },
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('feataure does not exist', async () => {
+      const result = featureFlagEvaluator('feature-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-feature/evaluators/tests/plan-targeting-rules.evaluator.spec.ts

@@ -0,0 +1,70 @@
+import * as PlanEvaluator from '../../../../plans/plan.evaluator';
+import { TreatmentEnum } from '../../../../rules';
+import { NotEntitledJustification } from '../../../types';
+import { planTargetingRulesEvalutor } from '../plan-targeting-rules.evaluator';
+describe('planTargetingRulesEvalutor', () => {
+  describe('entitled', () => {
+    test('some of the plans targeting rules return truthy', async () => {
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.True });
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.False });
+
+      const result = planTargetingRulesEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: ['plan-1', 'plan-2'],
+          },
+        },
+        permissions: {},
+        plans: {
+          'plan-1': {
+            defaultTreatment: TreatmentEnum.True,
+          },
+          'plan-2': {
+            defaultTreatment: TreatmentEnum.False,
+          },
+        },
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('all of the plans targeting rules return falsy', async () => {
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.False });
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.False });
+
+      const result = planTargetingRulesEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: ['plan-1', 'plan-2'],
+          },
+        },
+        permissions: {},
+        plans: {
+          'plan-1': {
+            defaultTreatment: TreatmentEnum.False,
+          },
+          'plan-2': {
+            defaultTreatment: TreatmentEnum.False,
+          },
+        },
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+
+    test('feature does not exist', async () => {
+      const result = planTargetingRulesEvalutor('feature-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-feature/evaluators/types.ts

@@ -0,0 +1,7 @@
+import { Attributes, EntitlementResult, UserEntitlementsContext } from '../../types';
+
+export type IsEntitledEvaluator = (
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes,
+) => EntitlementResult;

package/src/user-entitlements/is-entitled-to-feature/index.ts

@@ -0,0 +1 @@
+export * from './is-entitled-to-feature.evaluator';

package/src/user-entitlements/is-entitled-to-feature/is-entitled-to-feature.evaluator.ts

@@ -0,0 +1,18 @@
+import { EntitlementResult, NotEntitledJustification, UserEntitlementsContext, Attributes } from '../types';
+import { getResult, shouldContinue } from '../utils';
+import { getIsEntitledEvaluators } from './evaluators';
+export function evaluateIsEntitledToFeature(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const entitlementResults: EntitlementResult[] = [];
+  for (const evaluator of getIsEntitledEvaluators()) {
+    entitlementResults.push(evaluator(featureKey, userEntitlementsContext, attributes));
+    if (!shouldContinue(entitlementResults)) {
+      break;
+    }
+  }
+
+  return getResult(entitlementResults);
+}

package/src/user-entitlements/is-entitled-to-feature/tests/is-entitled-to-feature.evaluator.spec.ts

@@ -0,0 +1,68 @@
+import * as IsEntitledEvaluators from '../evaluators';
+import { evaluateIsEntitledToFeature } from '../is-entitled-to-feature.evaluator';
+import { EntitlementResult, NotEntitledJustification, NO_EXPIRATION_TIME, UserEntitlementsContext } from '../../types';
+
+describe('evaluateIsEntitledToFeature', () => {
+  const mockTruthyEvaluator = (): EntitlementResult => ({ isEntitled: true });
+  const mockFalsyMissingFeatureEvaluator = (): EntitlementResult => ({
+    isEntitled: false,
+    justification: NotEntitledJustification.MISSING_PERMISSION,
+  });
+  const mockFalsyExpiredEvaluator = (): EntitlementResult => ({
+    isEntitled: false,
+    justification: NotEntitledJustification.BUNDLE_EXPIRED,
+  });
+
+  describe('entitled', () => {
+    test('given all evaluators return truthy, feature is entitled', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockTruthyEvaluator, mockTruthyEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+    test('given some evaluators return truthy, feature is entitled', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockTruthyEvaluator, mockFalsyMissingFeatureEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('given all evaluators return falsy with missing feature, feature is not entitled, justified with missing feature', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockFalsyMissingFeatureEvaluator, mockFalsyMissingFeatureEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('given all evaluators return falsy, some with missing feature, some with bundle expired, feature is not entitled, justified with bundle expired', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockFalsyMissingFeatureEvaluator, mockFalsyExpiredEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-permission/index.ts

@@ -0,0 +1 @@
+export * from './is-entitled-to-permission.evaluator';

package/src/user-entitlements/is-entitled-to-permission/is-entitled-to-permission.evaluator.ts

@@ -0,0 +1,38 @@
+import { evaluateIsEntitledToFeature } from '../is-entitled-to-feature/is-entitled-to-feature.evaluator';
+import { UserEntitlementsContext, Attributes, EntitlementResult, NotEntitledJustification } from '../types';
+import { getResult, shouldContinue } from '../utils';
+import { checkPermission } from '../utils/permissions.utils';
+
+export function evaluateIsEntitledToPermissions(
+  permissionKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes?: Attributes,
+): EntitlementResult {
+  const hasPermission = checkPermission(userEntitlementsContext.permissions, permissionKey);
+  if (!hasPermission) {
+    return { isEntitled: false, justification: NotEntitledJustification.MISSING_PERMISSION };
+  }
+
+  const linkedFeatures = getLinkedFeatures(permissionKey, userEntitlementsContext);
+
+  if (!linkedFeatures.length) {
+    return { isEntitled: true };
+  }
+
+  const entitlementResults: EntitlementResult[] = [];
+  for (const featureKey of linkedFeatures) {
+    entitlementResults.push(evaluateIsEntitledToFeature(featureKey, userEntitlementsContext, attributes));
+
+    if (!shouldContinue(entitlementResults)) {
+      break;
+    }
+  }
+
+  return getResult(entitlementResults);
+}
+
+function getLinkedFeatures(permissionKey: string, userEntitlementsContext: UserEntitlementsContext): string[] {
+  return Object.keys(userEntitlementsContext.features).filter((featureKey) =>
+    userEntitlementsContext.features[featureKey].linkedPermissions.includes(permissionKey),
+  );
+}

package/src/user-entitlements/is-entitled-to-permission/tests/is-entitled-to-permission.evaluator.spec.ts

@@ -0,0 +1,79 @@
+import { evaluateIsEntitledToPermissions } from '../is-entitled-to-permission.evaluator';
+import { NO_EXPIRATION_TIME, NotEntitledJustification, UserEntitlementsContext } from '../../types';
+import * as IsEntitledToFeatureEvaluator from '../../is-entitled-to-feature/is-entitled-to-feature.evaluator';
+describe('evaluateIsEntitledToPermission', () => {
+  describe('entitled', () => {
+    test('permission granted, no linked feature/s to it', async () => {
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {},
+        plans: {},
+
+        permissions: { 'test.permission': true },
+      };
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+    test('permission granted with linked feature/s, feature is entitled', async () => {
+      jest.spyOn(IsEntitledToFeatureEvaluator, 'evaluateIsEntitledToFeature').mockReturnValue({ isEntitled: true });
+
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {
+          'test-feature': { planIds: [], expireTime: NO_EXPIRATION_TIME, linkedPermissions: ['test.permission'] },
+        },
+        plans: {},
+
+        permissions: { 'test.permission': true },
+      };
+
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+
+  describe('not entitled', () => {
+    test('permission not granted', async () => {
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {},
+        plans: {},
+        permissions: {},
+      };
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_PERMISSION });
+    });
+    test('permission granted with linked feature/s, no feature is entiteld', async () => {
+      jest
+        .spyOn(IsEntitledToFeatureEvaluator, 'evaluateIsEntitledToFeature')
+        .mockReturnValue({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: { 'test-feature': { planIds: [], expireTime: null, linkedPermissions: ['test.permission'] } },
+        plans: {},
+        permissions: { 'test.permission': true },
+      };
+
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('permission granted with linked feature/s, no feature is entiteld with expired bundle', async () => {
+      jest
+        .spyOn(IsEntitledToFeatureEvaluator, 'evaluateIsEntitledToFeature')
+        .mockReturnValue({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+
+    const userEntitlementContext: UserEntitlementsContext = {
+      features: {
+        'test-feature': { planIds: [], expireTime: Date.now() - 3600, linkedPermissions: ['test.permission'] },
+      },
+      plans: {},
+      permissions: { 'test.permission': true },
+    };
+
+    const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+    expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+  });
+});

package/src/user-entitlements/types.ts

@@ -1,20 +1,27 @@
 import { FeatureFlag } from '../feature-flags/types';
+import { Plan } from '../plans';
 export type UserEntitlementsContext = {
   features: Record<
     string,
     {
+      planIds: string[];
       expireTime: number | null;
       linkedPermissions: string[];
       featureFlag?: FeatureFlag;
     }
   >;
+  plans: Record<string, Plan>;
   permissions: Permissions;
 };
 
-export type EntitlementResult = {
-  isEntitled: boolean;
-  justification?: NotEntitledJustification;
-};
+export type EntitlementResult =
+  | {
+      isEntitled: true;
+    }
+  | {
+      isEntitled: false;
+      justification: NotEntitledJustification;
+    };
 
 export enum NotEntitledJustification {
   MISSING_FEATURE = 'MISSING_FEATURE',

package/src/user-entitlements/{attributes.utils.ts → utils/attributes.utils.ts}

@@ -1,4 +1,4 @@
-import { Attributes, JwtAttributes, FronteggAttributes } from './types';
+import { Attributes, JwtAttributes, FronteggAttributes } from '../types';
 import { flatten } from './flatten.utils';
 /**
  *  Merges both `custom` and `jwt` records, map Frontegg attributes and modifies record keys with corrisponding prefixes

package/src/user-entitlements/utils/entitlement-results.utils.ts

@@ -0,0 +1,22 @@
+import { EntitlementResult, NotEntitledJustification } from '../types';
+export function getResult(entitlementResults: EntitlementResult[]): EntitlementResult {
+  let hasExpired = false;
+  for (const entitlementResult of entitlementResults) {
+    if (entitlementResult.isEntitled) {
+      return entitlementResult;
+    }
+
+    if (entitlementResult.justification === NotEntitledJustification.BUNDLE_EXPIRED) {
+      hasExpired = true;
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: hasExpired ? NotEntitledJustification.BUNDLE_EXPIRED : NotEntitledJustification.MISSING_FEATURE,
+  };
+}
+
+export function shouldContinue(entitlementResults: EntitlementResult[]): boolean {
+  return entitlementResults.every(({ isEntitled }) => !isEntitled);
+}

package/src/user-entitlements/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './permissions.utils';
+export * from './attributes.utils';
+export * from './entitlement-results.utils';

package/src/user-entitlements/{permissions.utils.ts → utils/permissions.utils.ts}

@@ -1,4 +1,4 @@
-import { Permissions } from './types';
+import { Permissions } from '../types';
 export function checkPermission(permissions: Permissions, requiredPermission: string): boolean {
   return Object.keys(permissions).some((permissionKey) =>
     createPermissionCheckRegex(permissionKey).test(requiredPermission),

package/src/user-entitlements/{tests → utils/tests}/attributes.utils.spec.ts

@@ -1,5 +1,5 @@
 import * as AttributesUtils from '../attributes.utils';
-import { Attributes, FronteggAttributes, JwtAttributes } from '../types';
+import { Attributes, FronteggAttributes, JwtAttributes } from '../../types';
 describe('prepareAttributes', () => {
   test('given custom & jwt attributes, expected is merged & flatten attributes record', () => {
     const attributes: Attributes = {

package/src/user-entitlements/utils/tests/entitlement-results.utils.spec.ts

@@ -0,0 +1,46 @@
+import { EntitlementResult, NotEntitledJustification } from '../../types';
+import { getResult, shouldContinue } from '../entitlement-results.utils';
+describe('getResult', () => {
+  describe('entitled', () => {
+    test('given some of the results are truthy, exected is entitled', async () => {
+      const entitlementsResults: EntitlementResult[] = [
+        { isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE },
+        { isEntitled: true },
+      ];
+
+      const result = getResult(entitlementsResults);
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('given all of results are falsy with missing feature, expected is not entitled with missing feature justification', async () => {
+      const entitlementsResults: EntitlementResult[] = [
+        { isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE },
+        { isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE },
+      ];
+
+      const result = getResult(entitlementsResults);
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('given all of results are falsy with some expired, expected is not entitled with expired justification', async () => {
+      const entitlementsResults: EntitlementResult[] = [
+        { isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE },
+        { isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED },
+      ];
+
+      const result = getResult(entitlementsResults);
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+
+    test('given empty results, expected is not entitled with missing feature justification', async () => {
+      const entitlementsResults: EntitlementResult[] = [];
+
+      const result = getResult(entitlementsResults);
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/{tests → utils/tests}/permissions.utils.spec.ts

@@ -1,4 +1,4 @@
-import { Permissions } from '../types';
+import { Permissions } from '../../types';
 import { checkPermission } from '../permissions.utils';
 describe('checkPermission', () => {
   test.each([[{ 'test.permission': true }], [{ 'test.*': true }], [{ '*': true }]])(

package/dist/user-entitlements/attributes.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attributes.utils.js","sourceRoot":"","sources":["../../src/user-entitlements/attributes.utils.ts"],"names":[],"mappings":";;;AACA,mDAA0C;AAC1C;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAC/B,aAAyB,EAAE,EAC3B,8BAAqF;IAErF,MAAM,EAAE,MAAM,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,UAAU,CAAC;IAC7C,MAAM,iBAAiB,GAAG,IAAA,uBAAO,EAA+B,GAAG,CAAC,CAAC;IACrE,MAAM,kBAAkB,GAAG,8BAA8B;QACvD,CAAC,CAAC,8BAA8B,CAAC,GAAG,CAAC;QACrC,CAAC,CAAC,+BAA+B,CAAC,GAAG,CAAC,CAAC;IACzC,MAAM,wBAAwB,GAAG,WAAW,CAAC;IAC7C,MAAM,mBAAmB,GAAG,MAAM,CAAC;IAEnC,OAAO;QACL,GAAG,MAAM;QACT,GAAG,0BAA0B,CAAC,kBAAkB,EAAE,wBAAwB,CAAC;QAC3E,GAAG,0BAA0B,CAAC,iBAAiB,EAAE,mBAAmB,CAAC;KACtE,CAAC;AACJ,CAAC;AAjBD,8CAiBC;AAED,SAAgB,+BAA+B,CAAC,GAAkB;IAChE,OAAO;QACL,KAAK,EAAE,GAAG,CAAC,KAAe;QAC1B,aAAa,EAAE,GAAG,CAAC,cAAyB;QAC5C,QAAQ,EAAE,GAAG,CAAC,QAAkB;QAChC,MAAM,EAAE,GAAG,CAAC,EAAY;KACzB,CAAC;AACJ,CAAC;AAPD,0EAOC;AAED,SAAgB,0BAA0B,CAAC,MAA+B,EAAE,MAAc;IACxF,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,UAAU,EAAE,EAAE;QAC/D,cAAc,CAAC,GAAG,MAAM,GAAG,UAAU,EAAE,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC9D,OAAO,cAAc,CAAC;IACxB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AALD,gEAKC"}

package/dist/user-entitlements/flatten.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flatten.utils.js","sourceRoot":"","sources":["../../src/user-entitlements/flatten.utils.ts"],"names":[],"mappings":";;;AAQA,SAAgB,OAAO,CAAmB,MAAe,EAAE,IAAqB;IAC9E,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAElB,MAAM,SAAS,GAAG,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,SAAS,KAAI,GAAG,CAAC;IACzC,MAAM,QAAQ,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,QAAQ,CAAC;IAChC,MAAM,YAAY,GAAG,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,YAAY,KAAI,WAAW,CAAC;IACvD,MAAM,MAAM,GAAG,EAAE,CAAC;IAElB,SAAS,IAAI,CAAC,MAAM,EAAE,IAAK,EAAE,YAAa;QACxC,YAAY,GAAG,YAAY,IAAI,CAAC,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,UAAU,GAAG;YACvC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,MAAM,OAAO,GAAG,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI,KAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACnD,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnD,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;YACjC,MAAM,QAAQ,GAAG,IAAI,KAAK,iBAAiB,IAAI,IAAI,KAAK,gBAAgB,CAAC;YAEzE,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YAC/E,IACE,CAAC,OAAO;gBACR,CAAC,QAAQ;gBACT,QAAQ;gBACR,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM;gBACzB,CAAC,CAAC,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,QAAQ,CAAA,IAAI,CAAC,QAAQ,IAAI,YAAY,GAAG,QAAQ,CAAC,CAAC,EAC1D;gBACA,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC;aAC9C;YAED,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,CAAC;IAEb,OAAO,MAAiB,CAAC;AAC3B,CAAC;AAnCD,0BAmCC;AAED,SAAS,QAAQ,CAAC,GAAG;IACnB,OAAO,GAAG,IAAI,GAAG,CAAC,WAAW,IAAI,OAAO,GAAG,CAAC,WAAW,CAAC,QAAQ,KAAK,UAAU,IAAI,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AACnH,CAAC;AAED,SAAS,WAAW,CAAC,GAAG;IACtB,OAAO,GAAG,CAAC;AACb,CAAC"}