@frontegg/entitlements-javascript-commons 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export { FeatureFlagEvaluationResult, FeatureFlag, evaluateFeatureFlag } from '.
 export { TreatmentEnum, Rule } from './rules';
 export { Condition } from './conditions';
 export { OperationEnum, ConditionValue } from './operations/types';
+export { evaluateIsEntitledToFeature, evaluateIsEntitledToPermissions, CustomAttributes, NotEntitledJustification, UserEntitlementsContext, EntitlementResult, } from './user-entitlements';

package/dist/index.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationEnum = exports.TreatmentEnum = exports.evaluateFeatureFlag = void 0;
+exports.NotEntitledJustification = exports.evaluateIsEntitledToPermissions = exports.evaluateIsEntitledToFeature = exports.OperationEnum = exports.TreatmentEnum = exports.evaluateFeatureFlag = void 0;
 var feature_flags_1 = require("./feature-flags");
 Object.defineProperty(exports, "evaluateFeatureFlag", { enumerable: true, get: function () { return feature_flags_1.evaluateFeatureFlag; } });
 var rules_1 = require("./rules");
 Object.defineProperty(exports, "TreatmentEnum", { enumerable: true, get: function () { return rules_1.TreatmentEnum; } });
 var types_1 = require("./operations/types");
 Object.defineProperty(exports, "OperationEnum", { enumerable: true, get: function () { return types_1.OperationEnum; } });
+var user_entitlements_1 = require("./user-entitlements");
+Object.defineProperty(exports, "evaluateIsEntitledToFeature", { enumerable: true, get: function () { return user_entitlements_1.evaluateIsEntitledToFeature; } });
+Object.defineProperty(exports, "evaluateIsEntitledToPermissions", { enumerable: true, get: function () { return user_entitlements_1.evaluateIsEntitledToPermissions; } });
+Object.defineProperty(exports, "NotEntitledJustification", { enumerable: true, get: function () { return user_entitlements_1.NotEntitledJustification; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,iDAAgG;AAA7C,oHAAA,mBAAmB,OAAA;AACtE,iCAA8C;AAArC,sGAAA,aAAa,OAAA;AAEtB,4CAAmE;AAA1D,sGAAA,aAAa,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,iDAAgG;AAA7C,oHAAA,mBAAmB,OAAA;AACtE,iCAA8C;AAArC,sGAAA,aAAa,OAAA;AAEtB,4CAAmE;AAA1D,sGAAA,aAAa,OAAA;AACtB,yDAO6B;AAN3B,gIAAA,2BAA2B,OAAA;AAC3B,oIAAA,+BAA+B,OAAA;AAE/B,6HAAA,wBAAwB,OAAA"}

package/dist/user-entitlements/index.d.ts

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

package/dist/user-entitlements/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./is-entitled.evaluator"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/user-entitlements/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/user-entitlements/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0DAAwC;AACxC,0CAAwB"}

package/dist/user-entitlements/is-entitled.evaluator.d.ts

@@ -0,0 +1,3 @@
+import { CustomAttributes, EntitlementResult, UserEntitlementsContext } from './types';
+export declare function evaluateIsEntitledToFeature(featureKey: string, userEntitlementsContext: UserEntitlementsContext, attributes?: CustomAttributes): EntitlementResult;
+export declare function evaluateIsEntitledToPermissions(permissionKey: string, userEntitlementsContext: UserEntitlementsContext, attributes?: CustomAttributes): EntitlementResult;

package/dist/user-entitlements/is-entitled.evaluator.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateIsEntitledToPermissions = exports.evaluateIsEntitledToFeature = void 0;
+const types_1 = require("./types");
+const feature_flags_1 = require("../feature-flags");
+const rules_1 = require("../rules");
+function evaluateIsEntitledToFeature(featureKey, userEntitlementsContext, attributes = {}) {
+    const feature = userEntitlementsContext.features[featureKey];
+    let hasExpired = false;
+    if (feature && feature.expireTime !== null) {
+        hasExpired = feature.expireTime !== types_1.NO_EXPIRATION_TIME && feature.expireTime < Date.now();
+        if (!hasExpired) {
+            return { isEntitled: true };
+        }
+    }
+    if (feature && feature.featureFlag) {
+        const { treatment } = (0, feature_flags_1.evaluateFeatureFlag)(feature.featureFlag, attributes);
+        if (treatment === rules_1.TreatmentEnum.True) {
+            return { isEntitled: true };
+        }
+    }
+    return { isEntitled: false, justification: hasExpired ? types_1.NotEntitledJustification.BUNDLE_EXPIRED : types_1.NotEntitledJustification.MISSING_FEATURE };
+}
+exports.evaluateIsEntitledToFeature = evaluateIsEntitledToFeature;
+function evaluateIsEntitledToPermissions(permissionKey, userEntitlementsContext, attributes = {}) {
+    const permission = userEntitlementsContext.permissions[permissionKey];
+    if (!permission) {
+        return { isEntitled: false, justification: types_1.NotEntitledJustification.MISSING_PERMISSION };
+    }
+    const linkedFeatures = getLinkedFeatures(permissionKey, userEntitlementsContext);
+    if (!linkedFeatures.length) {
+        return { isEntitled: true };
+    }
+    let hasExpired = false;
+    for (const featureKey of linkedFeatures) {
+        const { isEntitled, justification } = evaluateIsEntitledToFeature(featureKey, userEntitlementsContext, attributes);
+        if (isEntitled) {
+            return { isEntitled: true };
+        }
+        if (justification === types_1.NotEntitledJustification.BUNDLE_EXPIRED) {
+            hasExpired = true;
+        }
+    }
+    return {
+        isEntitled: false,
+        justification: hasExpired ? types_1.NotEntitledJustification.BUNDLE_EXPIRED : types_1.NotEntitledJustification.MISSING_FEATURE,
+    };
+}
+exports.evaluateIsEntitledToPermissions = evaluateIsEntitledToPermissions;
+function getLinkedFeatures(permissionKey, userEntitlementsContext) {
+    return Object.keys(userEntitlementsContext.features).filter((featureKey) => userEntitlementsContext.features[featureKey].linkedPermissions.includes(permissionKey));
+}
+//# sourceMappingURL=is-entitled.evaluator.js.map

package/dist/user-entitlements/is-entitled.evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-entitled.evaluator.js","sourceRoot":"","sources":["../../src/user-entitlements/is-entitled.evaluator.ts"],"names":[],"mappings":";;;AAAA,mCAAqI;AACrI,oDAAuD;AACvD,oCAAyC;AACzC,SAAgB,2BAA2B,CACzC,UAAkB,EAClB,uBAAgD,EAChD,aAA+B,EAAE;IAEjC,MAAM,OAAO,GAAG,uBAAuB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAE7D,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,OAAO,IAAI,OAAO,CAAC,UAAU,KAAK,IAAI,EAAE;QAC1C,UAAU,GAAG,OAAO,CAAC,UAAU,KAAK,0BAAkB,IAAI,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE1F,IAAI,CAAC,UAAU,EAAE;YACf,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;SAC7B;KACF;IAED,IAAI,OAAO,IAAI,OAAO,CAAC,WAAW,EAAE;QAClC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAA,mCAAmB,EAAC,OAAO,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;QAC3E,IAAI,SAAS,KAAK,qBAAa,CAAC,IAAI,EAAE;YACpC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;SAC7B;KACF;IAED,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC,gCAAwB,CAAC,cAAc,CAAC,CAAC,CAAC,gCAAwB,CAAC,eAAe,EAAE,CAAC;AAC/I,CAAC;AAxBD,kEAwBC;AAED,SAAgB,+BAA+B,CAC7C,aAAqB,EACrB,uBAAgD,EAChD,aAA+B,EAAE;IAEjC,MAAM,UAAU,GAAG,uBAAuB,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAEtE,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,gCAAwB,CAAC,kBAAkB,EAAE,CAAC;KAC1F;IAED,MAAM,cAAc,GAAG,iBAAiB,CAAC,aAAa,EAAE,uBAAuB,CAAC,CAAC;IAEjF,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE;QAC1B,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;KAC7B;IAED,IAAI,UAAU,GAAG,KAAK,CAAC;IAEvB,KAAK,MAAM,UAAU,IAAI,cAAc,EAAE;QACvC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,2BAA2B,CAAC,UAAU,EAAE,uBAAuB,EAAE,UAAU,CAAC,CAAC;QAEnH,IAAI,UAAU,EAAE;YACd,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;SAC7B;QAED,IAAI,aAAa,KAAK,gCAAwB,CAAC,cAAc,EAAE;YAC7D,UAAU,GAAG,IAAI,CAAC;SACnB;KACF;IAED,OAAO;QACL,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC,gCAAwB,CAAC,cAAc,CAAC,CAAC,CAAC,gCAAwB,CAAC,eAAe;KAC/G,CAAC;AACJ,CAAC;AAnCD,0EAmCC;AAED,SAAS,iBAAiB,CAAC,aAAqB,EAAE,uBAAgD;IAChG,OAAO,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CACzE,uBAAuB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,aAAa,CAAC,CACvF,CAAC;AACJ,CAAC"}

package/dist/user-entitlements/types.d.ts

@@ -0,0 +1,20 @@
+import { FeatureFlag } from '../feature-flags/types';
+export type UserEntitlementsContext = {
+    features: Record<string, {
+        expireTime: number | null;
+        linkedPermissions: string[];
+        featureFlag?: FeatureFlag;
+    }>;
+    permissions: Record<string, true>;
+};
+export type EntitlementResult = {
+    isEntitled: boolean;
+    justification?: NotEntitledJustification;
+};
+export declare enum NotEntitledJustification {
+    MISSING_FEATURE = "MISSING_FEATURE",
+    MISSING_PERMISSION = "MISSING_PERMISSION",
+    BUNDLE_EXPIRED = "BUNDLE_EXPIRED"
+}
+export type CustomAttributes = Record<string, string | number | boolean | Date>;
+export declare const NO_EXPIRATION_TIME = -1;

package/dist/user-entitlements/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_EXPIRATION_TIME = exports.NotEntitledJustification = void 0;
+var NotEntitledJustification;
+(function (NotEntitledJustification) {
+    NotEntitledJustification["MISSING_FEATURE"] = "MISSING_FEATURE";
+    NotEntitledJustification["MISSING_PERMISSION"] = "MISSING_PERMISSION";
+    NotEntitledJustification["BUNDLE_EXPIRED"] = "BUNDLE_EXPIRED";
+})(NotEntitledJustification = exports.NotEntitledJustification || (exports.NotEntitledJustification = {}));
+exports.NO_EXPIRATION_TIME = -1;
+//# sourceMappingURL=types.js.map

package/dist/user-entitlements/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/user-entitlements/types.ts"],"names":[],"mappings":";;;AAkBA,IAAY,wBAIX;AAJD,WAAY,wBAAwB;IAClC,+DAAmC,CAAA;IACnC,qEAAyC,CAAA;IACzC,6DAAiC,CAAA;AACnC,CAAC,EAJW,wBAAwB,GAAxB,gCAAwB,KAAxB,gCAAwB,QAInC;AAIY,QAAA,kBAAkB,GAAG,CAAC,CAAC,CAAC"}

package/docs/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.0.0-alpha.7](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.6...v-1.0.0-alpha.7) (2023-10-11)
+
+
+### Features
+
+* **user-entitlements:** export function signature parameters types ([2207986](https://github.com/frontegg/entitlements-javascript-commons/commit/220798611a91875e594c83f76baed6c18f5ac19a))
+
+# [1.0.0-alpha.6](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.5...v-1.0.0-alpha.6) (2023-10-10)
+
+
+### Features
+
+* **user-entitlements:** add user entitlements evaluation logic ([d924a05](https://github.com/frontegg/entitlements-javascript-commons/commit/d924a056498b4b040dd765b262cde42201644653))
+
 # [1.0.0-alpha.5](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.4...v-1.0.0-alpha.5) (2023-10-10)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontegg/entitlements-javascript-commons",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.7",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -2,3 +2,11 @@ export { FeatureFlagEvaluationResult, FeatureFlag, evaluateFeatureFlag } from '.
 export { TreatmentEnum, Rule } from './rules';
 export { Condition } from './conditions';
 export { OperationEnum, ConditionValue } from './operations/types';
+export {
+  evaluateIsEntitledToFeature,
+  evaluateIsEntitledToPermissions,
+  CustomAttributes,
+  NotEntitledJustification,
+  UserEntitlementsContext,
+  EntitlementResult,
+} from './user-entitlements';

package/src/user-entitlements/index.ts

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

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

@@ -0,0 +1,71 @@
+import { CustomAttributes, EntitlementResult, NotEntitledJustification, NO_EXPIRATION_TIME, UserEntitlementsContext } from './types';
+import { evaluateFeatureFlag } from '../feature-flags';
+import { TreatmentEnum } from '../rules';
+export function evaluateIsEntitledToFeature(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: CustomAttributes = {},
+): EntitlementResult {
+  const feature = userEntitlementsContext.features[featureKey];
+
+  let hasExpired = false;
+  if (feature && feature.expireTime !== null) {
+    hasExpired = feature.expireTime !== NO_EXPIRATION_TIME && feature.expireTime < Date.now();
+
+    if (!hasExpired) {
+      return { isEntitled: true };
+    }
+  }
+
+  if (feature && feature.featureFlag) {
+    const { treatment } = evaluateFeatureFlag(feature.featureFlag, attributes);
+    if (treatment === TreatmentEnum.True) {
+      return { isEntitled: true };
+    }
+  }
+
+  return { isEntitled: false, justification: hasExpired ? NotEntitledJustification.BUNDLE_EXPIRED : NotEntitledJustification.MISSING_FEATURE };
+}
+
+export function evaluateIsEntitledToPermissions(
+  permissionKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: CustomAttributes = {},
+): EntitlementResult {
+  const permission = userEntitlementsContext.permissions[permissionKey];
+
+  if (!permission) {
+    return { isEntitled: false, justification: NotEntitledJustification.MISSING_PERMISSION };
+  }
+
+  const linkedFeatures = getLinkedFeatures(permissionKey, userEntitlementsContext);
+
+  if (!linkedFeatures.length) {
+    return { isEntitled: true };
+  }
+
+  let hasExpired = false;
+
+  for (const featureKey of linkedFeatures) {
+    const { isEntitled, justification } = evaluateIsEntitledToFeature(featureKey, userEntitlementsContext, attributes);
+
+    if (isEntitled) {
+      return { isEntitled: true };
+    }
+
+    if (justification === NotEntitledJustification.BUNDLE_EXPIRED) {
+      hasExpired = true;
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: hasExpired ? NotEntitledJustification.BUNDLE_EXPIRED : NotEntitledJustification.MISSING_FEATURE,
+  };
+}
+
+function getLinkedFeatures(permissionKey: string, userEntitlementsContext: UserEntitlementsContext): string[] {
+  return Object.keys(userEntitlementsContext.features).filter((featureKey) =>
+    userEntitlementsContext.features[featureKey].linkedPermissions.includes(permissionKey),
+  );
+}

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

@@ -0,0 +1,291 @@
+import * as FeatureFlags from '../../feature-flags/feature-flag.evaluator';
+import * as IsEntitledEvaluators from '../is-entitled.evaluator';
+import { TreatmentEnum } from '../../rules';
+import { EntitlementResult, NotEntitledJustification, NO_EXPIRATION_TIME, UserEntitlementsContext } from '../types';
+import { FeatureFlag } from '../../feature-flags/types';
+const mockFeatureFlag: FeatureFlag = {
+  on: true,
+  defaultTreatment: TreatmentEnum.True,
+  offTreatment: TreatmentEnum.False,
+  rules: [],
+};
+const truthyEntitlementResult: EntitlementResult = {
+  isEntitled: true,
+};
+const falsyEntitlementResultMissingFeature: EntitlementResult = {
+  isEntitled: false,
+  justification: NotEntitledJustification.MISSING_FEATURE,
+};
+const falsyEntitlementResultBundleExpired: EntitlementResult = {
+  isEntitled: false,
+  justification: NotEntitledJustification.BUNDLE_EXPIRED,
+};
+const falsyEntitlementResultMissingPermission: EntitlementResult = {
+  isEntitled: false,
+  justification: NotEntitledJustification.MISSING_PERMISSION,
+};
+describe('evaluateIsEntitledToFeature', () => {
+  describe('entitled', () => {
+    describe('feature-flag evaluated truthy', () => {
+      beforeAll(async () => {
+        jest.spyOn(FeatureFlags, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.True });
+      });
+
+      test('feature granted with valid expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: new Date().getTime() + 3600,
+              linkedPermissions: [],
+              featureFlag: mockFeatureFlag,
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+      test('feature granted with expired expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: new Date().getTime() - 3600,
+              linkedPermissions: [],
+              featureFlag: mockFeatureFlag,
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+      test('feature granted with no expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: NO_EXPIRATION_TIME,
+              linkedPermissions: [],
+              featureFlag: mockFeatureFlag,
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+      test('feature has not been granted', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: null,
+              linkedPermissions: [],
+              featureFlag: mockFeatureFlag,
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+    });
+    describe('feature-flag evaluated falsy', () => {
+      beforeAll(async () => {
+        jest.spyOn(FeatureFlags, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.False });
+      });
+      test('feature granted with no expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: NO_EXPIRATION_TIME,
+              linkedPermissions: [],
+              featureFlag: mockFeatureFlag,
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+      test('feature granted with valid expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: Date.now() + 3600,
+              linkedPermissions: [],
+              featureFlag: mockFeatureFlag,
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+    });
+    describe('no feature flag', () => {
+      test('feature granted with no expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: NO_EXPIRATION_TIME,
+              linkedPermissions: [],
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+      test('feature granted with valid expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: Date.now() + 3600,
+              linkedPermissions: [],
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(truthyEntitlementResult);
+      });
+    });
+  });
+
+  describe('not entitled', () => {
+    describe('feature-flag evaluated falsy', () => {
+      beforeAll(async () => {
+        jest.spyOn(FeatureFlags, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.False });
+      });
+      test('feature has not been granted', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: null,
+              linkedPermissions: [],
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(falsyEntitlementResultMissingFeature);
+      });
+      test('feature granted with expired expiration date', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {
+            'test-feature': {
+              expireTime: Date.now() - 3600,
+              linkedPermissions: [],
+            },
+          },
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(falsyEntitlementResultBundleExpired);
+      });
+    });
+
+    describe('no feature', () => {
+      test('feature does not exist', async () => {
+        const userEntitlementContext: UserEntitlementsContext = {
+          features: {},
+          permissions: {},
+        };
+        const result = IsEntitledEvaluators.evaluateIsEntitledToFeature('test-feature', userEntitlementContext, {});
+
+        expect(result).toEqual(falsyEntitlementResultMissingFeature);
+      });
+    });
+  });
+});
+
+describe('evaluateIsEntitledToPermission', () => {
+  describe('entitled', () => {
+    test('permission granted, no linked feature/s to it', async () => {
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {},
+        permissions: { 'test.permission': true },
+      };
+      const result = IsEntitledEvaluators.evaluateIsEntitledToPermissions(
+        'test.permission',
+        userEntitlementContext,
+        {},
+      );
+
+      expect(result).toEqual(truthyEntitlementResult);
+    });
+    test('permission granted with linked feature/s, feature is entitled', async () => {
+      jest.spyOn(IsEntitledEvaluators, 'evaluateIsEntitledToFeature').mockReturnValue({ isEntitled: true });
+
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: { 'test-feature': { expireTime: NO_EXPIRATION_TIME, linkedPermissions: ['test.permission'] } },
+        permissions: { 'test.permission': true },
+      };
+
+      const result = IsEntitledEvaluators.evaluateIsEntitledToPermissions(
+        'test.permission',
+        userEntitlementContext,
+        {},
+      );
+
+      expect(result).toEqual(truthyEntitlementResult);
+    });
+  });
+
+  describe('not entitled', () => {
+    test('permission not granted', async () => {
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {},
+        permissions: {},
+      };
+      const result = IsEntitledEvaluators.evaluateIsEntitledToPermissions(
+        'test.permission',
+        userEntitlementContext,
+        {},
+      );
+
+      expect(result).toEqual(falsyEntitlementResultMissingPermission);
+    });
+    test('permission granted with linked feature/s, no feature is entiteld', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'evaluateIsEntitledToFeature')
+        .mockReturnValue({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: { 'test-feature': { expireTime: null, linkedPermissions: ['test.permission'] } },
+        permissions: { 'test.permission': true },
+      };
+
+      const result = IsEntitledEvaluators.evaluateIsEntitledToPermissions(
+        'test.permission',
+        userEntitlementContext,
+        {},
+      );
+
+      expect(result).toEqual(falsyEntitlementResultMissingFeature);
+    });
+    test('permission granted with linked feature/s, no feature is entiteld with expired bundle', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'evaluateIsEntitledToFeature')
+        .mockReturnValue({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+
+    const userEntitlementContext: UserEntitlementsContext = {
+      features: { 'test-feature': { expireTime: Date.now() - 3600, linkedPermissions: ['test.permission'] } },
+      permissions: { 'test.permission': true },
+    };
+
+    const result = IsEntitledEvaluators.evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+    expect(result).toEqual(falsyEntitlementResultBundleExpired);
+  });
+});

package/src/user-entitlements/types.ts

@@ -0,0 +1,27 @@
+import { FeatureFlag } from '../feature-flags/types';
+export type UserEntitlementsContext = {
+  features: Record<
+    string,
+    {
+      expireTime: number | null;
+      linkedPermissions: string[];
+      featureFlag?: FeatureFlag;
+    }
+  >;
+  permissions: Record<string, true>;
+};
+
+export type EntitlementResult = {
+  isEntitled: boolean;
+  justification?: NotEntitledJustification;
+};
+
+export enum NotEntitledJustification {
+  MISSING_FEATURE = 'MISSING_FEATURE',
+  MISSING_PERMISSION = 'MISSING_PERMISSION',
+  BUNDLE_EXPIRED = 'BUNDLE_EXPIRED',
+}
+
+export type CustomAttributes = Record<string, string | number | boolean | Date>;
+
+export const NO_EXPIRATION_TIME = -1;