@stigg/node-server-sdk 4.10.0 → 4.12.0

package/dist/services/cache/entities/calculatedEntitlement.d.ts

@@ -0,0 +1,34 @@
+import { EntitlementType, ResetPeriodConfigurationFragment, EntitlementResetPeriod, AccessDeniedReason } from '@stigg/api-client-js/src/generated/sdk';
+import { EntitlementCreditRate, EntitlementFeature } from '../types/entitlementFeature';
+/**
+ * Note: Optional fields use `| null` instead of `?` to ensure they are explicitly
+ * mapped by the CacheMapper {@link CacheMapper}. Using optional properties (`?`)
+ * could result in fields being omitted during mapping, whereas `| null` ensures they
+ * are always present.
+ */
+interface BaseCalculatedEntitlement {
+    type: EntitlementType;
+    accessDeniedReason: AccessDeniedReason | null;
+    validUntil: number | null;
+}
+export interface CalculatedFeatureEntitlement extends BaseCalculatedEntitlement {
+    type: EntitlementType.Feature;
+    feature: EntitlementFeature;
+    usageLimit: number | null;
+    enumValues: string[] | null;
+    hasUnlimitedUsage: boolean;
+    hasSoftLimit: boolean;
+    usagePeriodAnchor: number | null;
+    resetPeriod: EntitlementResetPeriod | null;
+    resetPeriodConfiguration: ResetPeriodConfigurationFragment | null;
+    creditRate: EntitlementCreditRate | null;
+}
+export interface CalculatedCreditEntitlement extends BaseCalculatedEntitlement {
+    type: EntitlementType.Credit;
+    currency: {
+        currencyId: string;
+    };
+    usageLimit: number;
+}
+export type CalculatedEntitlement = CalculatedFeatureEntitlement | CalculatedCreditEntitlement;
+export {};

package/dist/services/cache/entities/calculatedEntitlement.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlZEVudGl0bGVtZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2NhY2hlL2VudGl0aWVzL2NhbGN1bGF0ZWRFbnRpdGxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/services/cache/entities/entitlementQuery.d.ts

@@ -0,0 +1,8 @@
+import { EntitlementType } from '@stigg/api-client-js/src/generated/sdk';
+/** Query to look up an entitlement by type and id */
+export type EntitlementQuery<T extends EntitlementType = EntitlementType> = {
+    /** The entitlement type */
+    type: T;
+    /** The unique identifier of the entitlement type */
+    id: string;
+};

package/dist/services/cache/entities/entitlementQuery.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXRsZW1lbnRRdWVyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9jYWNoZS9lbnRpdGllcy9lbnRpdGxlbWVudFF1ZXJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/services/cache/entities/entitlementsMap.d.ts

@@ -0,0 +1,33 @@
+import { CachedEntitlement } from './cachedEntitlement';
+import { EntitlementType } from '@stigg/api-client-js/src/generated/sdk';
+import { EntitlementQuery } from './entitlementQuery';
+import { UsageData } from './usageData';
+import { CacheMapper } from '../CacheMapper';
+/**
+ * Type-safe wrapper around Map<string, CachedEntitlement> that encapsulates key building.
+ * Prevents errors from manual string key lookups.
+ */
+export declare class EntitlementsMap {
+    private readonly map;
+    protected constructor(entries?: Iterable<CachedEntitlement>);
+    static getUniqueKey(query: EntitlementQuery): string;
+    get<T extends EntitlementType>(query: EntitlementQuery<T>): CachedEntitlement<T> | undefined;
+    set(entitlement: CachedEntitlement): this;
+    get size(): number;
+    values(): CachedEntitlement[];
+    /** Updates usage data for an entitlement. Returns the updated entitlement or null if not found. */
+    updateUsage<T extends EntitlementType>(entitlementReference: EntitlementQuery<T>, usageData: UsageData): void;
+    toJSON(): Record<string, CachedEntitlement>;
+    static fromJSON(obj: Record<string, unknown>): EntitlementsMap;
+    static empty(): EntitlementsMap;
+    static fromEntitlements(entries: Iterable<CachedEntitlement>): EntitlementsMap;
+    /**
+     * Creates an EntitlementsMap by mapping raw inputs using the provided mapper.
+     * Filters out null results automatically.
+     * Returns both the map and a map of usageUpdatedAt timestamps keyed by entitlement key.
+     */
+    static fromInput<T>(mapper: CacheMapper<T>, inputs: T[]): {
+        entitlements: EntitlementsMap;
+        usageUpdatedAtMap: Map<string, Date>;
+    };
+}

package/dist/services/cache/entities/entitlementsMap.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementsMap = void 0;
+const lodash_1 = require("lodash");
+const cachedEntitlement_1 = require("./cachedEntitlement");
+const sdk_1 = require("@stigg/api-client-js/src/generated/sdk");
+/**
+ * Type-safe wrapper around Map<string, CachedEntitlement> that encapsulates key building.
+ * Prevents errors from manual string key lookups.
+ */
+class EntitlementsMap {
+    constructor(entries) {
+        this.map = new Map();
+        if (entries) {
+            for (const entitlement of entries) {
+                this.set(entitlement);
+            }
+        }
+    }
+    // Feature entitlements use raw ID for backward compatibility with existing cache data
+    // Credit entitlements use prefix since they're new and need to be distinguishable
+    static getUniqueKey(query) {
+        if (query.type === sdk_1.EntitlementType.Feature) {
+            return query.id;
+        }
+        return `${query.type}:${query.id}`;
+    }
+    get(query) {
+        return this.map.get(EntitlementsMap.getUniqueKey(query));
+    }
+    set(entitlement) {
+        const key = EntitlementsMap.getUniqueKey(entitlement.getEntitlementQuery());
+        this.map.set(key, entitlement);
+        return this;
+    }
+    get size() {
+        return this.map.size;
+    }
+    values() {
+        return Array.from(this.map.values());
+    }
+    /** Updates usage data for an entitlement. Returns the updated entitlement or null if not found. */
+    updateUsage(entitlementReference, usageData) {
+        const existingEntitlement = this.get(entitlementReference);
+        if (!existingEntitlement) {
+            return;
+        }
+        const updatedEntitlement = new cachedEntitlement_1.CachedEntitlement(existingEntitlement.calculatedEntitlement, usageData);
+        this.set(updatedEntitlement);
+    }
+    // For serialization (Redis)
+    toJSON() {
+        return Object.fromEntries(this.map);
+    }
+    // For deserialization (Redis)
+    static fromJSON(obj) {
+        const map = new EntitlementsMap();
+        for (const [key, value] of Object.entries(obj)) {
+            const entitlementData = value;
+            // Create actual CachedEntitlement instance (not just a plain object) so instance methods work
+            const entitlement = new cachedEntitlement_1.CachedEntitlement(entitlementData.calculatedEntitlement, entitlementData.usageData);
+            map.map.set(key, entitlement);
+        }
+        return map;
+    }
+    static empty() {
+        return new EntitlementsMap();
+    }
+    static fromEntitlements(entries) {
+        return new EntitlementsMap(entries);
+    }
+    /**
+     * Creates an EntitlementsMap by mapping raw inputs using the provided mapper.
+     * Filters out null results automatically.
+     * Returns both the map and a map of usageUpdatedAt timestamps keyed by entitlement key.
+     */
+    static fromInput(mapper, inputs) {
+        const entitlements = new EntitlementsMap();
+        const usageUpdatedAtMap = new Map();
+        const mappedEntitlements = (0, lodash_1.compact)(inputs.map((input) => mapper.mapEntitlement(input)));
+        for (const { entitlement, usageUpdatedAt } of mappedEntitlements) {
+            entitlements.set(entitlement);
+            if (usageUpdatedAt) {
+                const key = EntitlementsMap.getUniqueKey(entitlement.getEntitlementQuery());
+                usageUpdatedAtMap.set(key, new Date(usageUpdatedAt));
+            }
+        }
+        return { entitlements, usageUpdatedAtMap };
+    }
+}
+exports.EntitlementsMap = EntitlementsMap;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/cache/entities/index.d.ts

@@ -0,0 +1,6 @@
+export { EntitlementType } from '@stigg/api-client-js/src/generated/sdk';
+export { EntitlementQuery } from './entitlementQuery';
+export { CalculatedEntitlement, CalculatedFeatureEntitlement, CalculatedCreditEntitlement, } from './calculatedEntitlement';
+export { UsageData } from './usageData';
+export { CachedEntitlement, isFeatureEntitlement, isCreditEntitlement } from './cachedEntitlement';
+export { EntitlementsMap } from './entitlementsMap';

package/dist/services/cache/entities/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementsMap = exports.isCreditEntitlement = exports.isFeatureEntitlement = exports.CachedEntitlement = exports.EntitlementType = void 0;
+var sdk_1 = require("@stigg/api-client-js/src/generated/sdk");
+Object.defineProperty(exports, "EntitlementType", { enumerable: true, get: function () { return sdk_1.EntitlementType; } });
+var cachedEntitlement_1 = require("./cachedEntitlement");
+Object.defineProperty(exports, "CachedEntitlement", { enumerable: true, get: function () { return cachedEntitlement_1.CachedEntitlement; } });
+Object.defineProperty(exports, "isFeatureEntitlement", { enumerable: true, get: function () { return cachedEntitlement_1.isFeatureEntitlement; } });
+Object.defineProperty(exports, "isCreditEntitlement", { enumerable: true, get: function () { return cachedEntitlement_1.isCreditEntitlement; } });
+var entitlementsMap_1 = require("./entitlementsMap");
+Object.defineProperty(exports, "EntitlementsMap", { enumerable: true, get: function () { return entitlementsMap_1.EntitlementsMap; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvY2FjaGUvZW50aXRpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsOERBQXlFO0FBQWhFLHNHQUFBLGVBQWUsT0FBQTtBQVF4Qix5REFBbUc7QUFBMUYsc0hBQUEsaUJBQWlCLE9BQUE7QUFBRSx5SEFBQSxvQkFBb0IsT0FBQTtBQUFFLHdIQUFBLG1CQUFtQixPQUFBO0FBQ3JFLHFEQUFvRDtBQUEzQyxrSEFBQSxlQUFlLE9BQUEifQ==

package/dist/services/cache/entities/usageData.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Note: Optional fields use `| null` instead of `?` to ensure they are explicitly
+ * mapped by the CacheMapper {@link CacheMapper}. Using optional properties (`?`)
+ * could result in fields being omitted during mapping, whereas `| null` ensures they
+ * are always present.
+ */
+export interface UsageData {
+    currentUsage: number;
+    usagePeriodStart: number | null;
+    usagePeriodEnd: number | null;
+}

package/dist/services/cache/entities/usageData.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Note: Optional fields use `| null` instead of `?` to ensure they are explicitly
+ * mapped by the CacheMapper {@link CacheMapper}. Using optional properties (`?`)
+ * could result in fields being omitted during mapping, whereas `| null` ensures they
+ * are always present.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNhZ2VEYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2NhY2hlL2VudGl0aWVzL3VzYWdlRGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7O0dBS0cifQ==

package/dist/services/cache/extractWithDependencies.d.ts

@@ -0,0 +1,12 @@
+import { EntitlementsMap, EntitlementQuery } from './entities';
+import { EntitlementsMapTransformer } from './types/entitlementsMapTransformer';
+/**
+ * Extracts the requested entitlement along with its dependencies (e.g., credit entitlement for features with creditRate).
+ * Returns an empty map if the entitlement is not found.
+ */
+export declare class ExtractWithDependencies implements EntitlementsMapTransformer {
+    private readonly query;
+    constructor(query: EntitlementQuery);
+    transform(entitlements: EntitlementsMap): EntitlementsMap;
+    private getCreditRateDependency;
+}

package/dist/services/cache/extractWithDependencies.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractWithDependencies = void 0;
+const lodash_1 = require("lodash");
+const entities_1 = require("./entities");
+/**
+ * Extracts the requested entitlement along with its dependencies (e.g., credit entitlement for features with creditRate).
+ * Returns an empty map if the entitlement is not found.
+ */
+class ExtractWithDependencies {
+    constructor(query) {
+        this.query = query;
+    }
+    transform(entitlements) {
+        const entitlement = entitlements.get(this.query);
+        if (!entitlement) {
+            return entities_1.EntitlementsMap.empty();
+        }
+        const credit = this.getCreditRateDependency(entitlement, entitlements);
+        return entities_1.EntitlementsMap.fromEntitlements((0, lodash_1.compact)([entitlement, credit]));
+    }
+    getCreditRateDependency(entitlement, entitlements) {
+        if (!(0, entities_1.isFeatureEntitlement)(entitlement)) {
+            return undefined;
+        }
+        const creditRate = entitlement.calculatedEntitlement.creditRate;
+        if (!creditRate) {
+            return undefined;
+        }
+        return entitlements.get({
+            type: entities_1.EntitlementType.Credit,
+            id: creditRate.currencyId,
+        });
+    }
+}
+exports.ExtractWithDependencies = ExtractWithDependencies;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmFjdFdpdGhEZXBlbmRlbmNpZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvY2FjaGUvZXh0cmFjdFdpdGhEZXBlbmRlbmNpZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQWlDO0FBQ2pDLHlDQU1vQjtBQUdwQjs7O0dBR0c7QUFDSCxNQUFhLHVCQUF1QjtJQUNsQyxZQUE2QixLQUF1QjtRQUF2QixVQUFLLEdBQUwsS0FBSyxDQUFrQjtJQUFHLENBQUM7SUFFeEQsU0FBUyxDQUFDLFlBQTZCO1FBQ3JDLE1BQU0sV0FBVyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ2pELElBQUksQ0FBQyxXQUFXLEVBQUU7WUFDaEIsT0FBTywwQkFBZSxDQUFDLEtBQUssRUFBRSxDQUFDO1NBQ2hDO1FBRUQsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLHVCQUF1QixDQUFDLFdBQVcsRUFBRSxZQUFZLENBQUMsQ0FBQztRQUV2RSxPQUFPLDBCQUFlLENBQUMsZ0JBQWdCLENBQUMsSUFBQSxnQkFBTyxFQUFDLENBQUMsV0FBVyxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBRU8sdUJBQXVCLENBQzdCLFdBQWlDLEVBQ2pDLFlBQTZCO1FBRTdCLElBQUksQ0FBQyxJQUFBLCtCQUFvQixFQUFDLFdBQVcsQ0FBQyxFQUFFO1lBQ3RDLE9BQU8sU0FBUyxDQUFDO1NBQ2xCO1FBRUQsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLHFCQUFxQixDQUFDLFVBQVUsQ0FBQztRQUNoRSxJQUFJLENBQUMsVUFBVSxFQUFFO1lBQ2YsT0FBTyxTQUFTLENBQUM7U0FDbEI7UUFFRCxPQUFPLFlBQVksQ0FBQyxHQUFHLENBQUM7WUFDdEIsSUFBSSxFQUFFLDBCQUFlLENBQUMsTUFBTTtZQUM1QixFQUFFLEVBQUUsVUFBVSxDQUFDLFVBQVU7U0FDMUIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBaENELDBEQWdDQyJ9

package/dist/services/cache/freshness/EntitlementsFreshener.d.ts

@@ -0,0 +1,11 @@
+import { EntitlementsMap } from '../entities';
+import { EntitlementsMapTransformer } from '../types/entitlementsMapTransformer';
+/**
+ * Ensures cached entitlements reflect the current state at read time.
+ * Cached data may become stale between writes, so this applies
+ * transformations to correct time-sensitive values before returning.
+ */
+export declare class EntitlementsFreshener implements EntitlementsMapTransformer {
+    private readonly transformations;
+    transform(entitlements: EntitlementsMap): EntitlementsMap;
+}

package/dist/services/cache/freshness/EntitlementsFreshener.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementsFreshener = void 0;
+const UsagePeriodReset_1 = require("./transformers/UsagePeriodReset");
+const CreditAccessPropagator_1 = require("./transformers/CreditAccessPropagator");
+/**
+ * Ensures cached entitlements reflect the current state at read time.
+ * Cached data may become stale between writes, so this applies
+ * transformations to correct time-sensitive values before returning.
+ */
+class EntitlementsFreshener {
+    constructor() {
+        this.transformations = [
+            new UsagePeriodReset_1.UsagePeriodReset(),
+            new CreditAccessPropagator_1.CreditAccessPropagator(),
+        ];
+    }
+    transform(entitlements) {
+        let result = entitlements;
+        for (const transformation of this.transformations) {
+            result = transformation.transform(result);
+        }
+        return result;
+    }
+}
+exports.EntitlementsFreshener = EntitlementsFreshener;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRW50aXRsZW1lbnRzRnJlc2hlbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2NhY2hlL2ZyZXNobmVzcy9FbnRpdGxlbWVudHNGcmVzaGVuZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsc0VBQW1FO0FBQ25FLGtGQUErRTtBQUUvRTs7OztHQUlHO0FBQ0gsTUFBYSxxQkFBcUI7SUFBbEM7UUFDbUIsb0JBQWUsR0FBaUM7WUFDL0QsSUFBSSxtQ0FBZ0IsRUFBRTtZQUN0QixJQUFJLCtDQUFzQixFQUFFO1NBQzdCLENBQUM7SUFXSixDQUFDO0lBVEMsU0FBUyxDQUFDLFlBQTZCO1FBQ3JDLElBQUksTUFBTSxHQUFHLFlBQVksQ0FBQztRQUUxQixLQUFLLE1BQU0sY0FBYyxJQUFJLElBQUksQ0FBQyxlQUFlLEVBQUU7WUFDakQsTUFBTSxHQUFHLGNBQWMsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDM0M7UUFFRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0NBQ0Y7QUFmRCxzREFlQyJ9

package/dist/services/cache/freshness/transformers/CreditAccessPropagator.d.ts

@@ -0,0 +1,15 @@
+import { EntitlementsMap } from '../../entities';
+import { EntitlementsMapTransformer } from '../../types/entitlementsMapTransformer';
+/**
+ * Propagates credit access state to features linked via creditRate.
+ * - Sets InsufficientCredits when linked credit balance is depleted
+ * - Clears InsufficientCredits when linked credit balance is restored
+ */
+export declare class CreditAccessPropagator implements EntitlementsMapTransformer {
+    transform(entitlements: EntitlementsMap): EntitlementsMap;
+    private processEntitlement;
+    private getCachedCreditAccessReason;
+    private getCreditAccessDeniedReason;
+    private hasSufficientCredits;
+    private withCreditAccessReason;
+}

package/dist/services/cache/freshness/transformers/CreditAccessPropagator.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditAccessPropagator = void 0;
+const entities_1 = require("../../entities");
+const sdk_1 = require("@stigg/api-client-js/src/generated/sdk");
+/**
+ * Propagates credit access state to features linked via creditRate.
+ * - Sets InsufficientCredits when linked credit balance is depleted
+ * - Clears InsufficientCredits when linked credit balance is restored
+ */
+class CreditAccessPropagator {
+    transform(entitlements) {
+        const result = entities_1.EntitlementsMap.empty();
+        // Cache credit access reason per currencyId to avoid redundant
+        // lookups when multiple features share the same currency
+        const creditAccessCache = new Map();
+        for (const entitlement of entitlements.values()) {
+            result.set(this.processEntitlement(entitlement, entitlements, creditAccessCache));
+        }
+        return result;
+    }
+    processEntitlement(entitlement, entitlements, cache) {
+        if (!(0, entities_1.isFeatureEntitlement)(entitlement) || !entitlement.calculatedEntitlement.creditRate) {
+            return entitlement;
+        }
+        const { currencyId } = entitlement.calculatedEntitlement.creditRate;
+        const creditAccessReason = this.getCachedCreditAccessReason(currencyId, entitlements, cache);
+        return this.withCreditAccessReason(entitlement, creditAccessReason);
+    }
+    getCachedCreditAccessReason(currencyId, entitlements, cache) {
+        const cached = cache.get(currencyId);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const credit = entitlements.get({
+            type: entities_1.EntitlementType.Credit,
+            id: currencyId,
+        });
+        const reason = this.getCreditAccessDeniedReason(credit);
+        cache.set(currencyId, reason);
+        return reason;
+    }
+    getCreditAccessDeniedReason(credit) {
+        if (credit && this.hasSufficientCredits(credit)) {
+            return null;
+        }
+        return sdk_1.AccessDeniedReason.InsufficientCredits;
+    }
+    hasSufficientCredits(credit) {
+        const { usageLimit } = credit.calculatedEntitlement;
+        const { currentUsage } = credit.usageData;
+        return usageLimit - currentUsage > 0;
+    }
+    withCreditAccessReason(entitlement, creditAccessReason) {
+        const currentReason = entitlement.calculatedEntitlement.accessDeniedReason;
+        // Don't overwrite other access denied reasons
+        if (currentReason !== null && currentReason !== sdk_1.AccessDeniedReason.InsufficientCredits) {
+            return entitlement;
+        }
+        if (creditAccessReason === currentReason) {
+            return entitlement;
+        }
+        return new entities_1.CachedEntitlement(Object.assign(Object.assign({}, entitlement.calculatedEntitlement), { accessDeniedReason: creditAccessReason }), entitlement.usageData);
+    }
+}
+exports.CreditAccessPropagator = CreditAccessPropagator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/cache/freshness/transformers/UsagePeriodReset.d.ts

@@ -0,0 +1,11 @@
+import { EntitlementsMap } from '../../entities';
+import { EntitlementsMapTransformer } from '../../types/entitlementsMapTransformer';
+/**
+ * Resets usage data when the usage period has ended.
+ * For metered features, if the current time is past usagePeriodEnd,
+ * resets currentUsage to 0 and recalculates the period boundaries.
+ */
+export declare class UsagePeriodReset implements EntitlementsMapTransformer {
+    transform(entitlements: EntitlementsMap): EntitlementsMap;
+    private transformEntitlement;
+}

package/dist/services/cache/freshness/transformers/UsagePeriodReset.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsagePeriodReset = void 0;
+const entities_1 = require("../../entities");
+const featureTypes_1 = require("../../../../utils/featureTypes");
+const calculateUsagePeriod_1 = require("../../../../utils/calculateUsagePeriod");
+/**
+ * Resets usage data when the usage period has ended.
+ * For metered features, if the current time is past usagePeriodEnd,
+ * resets currentUsage to 0 and recalculates the period boundaries.
+ */
+class UsagePeriodReset {
+    transform(entitlements) {
+        const now = new Date();
+        const result = entities_1.EntitlementsMap.empty();
+        for (const entitlement of entitlements.values()) {
+            result.set(this.transformEntitlement(entitlement, now));
+        }
+        return result;
+    }
+    transformEntitlement(entitlement, now) {
+        var _a, _b;
+        if (!(0, entities_1.isFeatureEntitlement)(entitlement)) {
+            return entitlement;
+        }
+        const { calculatedEntitlement, usageData } = entitlement;
+        const wasPeriodOver = (0, featureTypes_1.isMetered)(calculatedEntitlement.feature) && usageData.usagePeriodEnd && usageData.usagePeriodEnd < now.getTime();
+        if (!wasPeriodOver) {
+            return entitlement;
+        }
+        const { resetPeriod, usagePeriodAnchor } = calculatedEntitlement;
+        let usagePeriodStart;
+        let usagePeriodEnd;
+        if (usagePeriodAnchor && resetPeriod) {
+            ({ usagePeriodStart, usagePeriodEnd } = (0, calculateUsagePeriod_1.calculateUsagePeriod)(new Date(usagePeriodAnchor), now, resetPeriod));
+        }
+        return new entities_1.CachedEntitlement(calculatedEntitlement, {
+            currentUsage: 0,
+            usagePeriodStart: (_a = usagePeriodStart === null || usagePeriodStart === void 0 ? void 0 : usagePeriodStart.getTime()) !== null && _a !== void 0 ? _a : null,
+            usagePeriodEnd: (_b = usagePeriodEnd === null || usagePeriodEnd === void 0 ? void 0 : usagePeriodEnd.getTime()) !== null && _b !== void 0 ? _b : null,
+        });
+    }
+}
+exports.UsagePeriodReset = UsagePeriodReset;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXNhZ2VQZXJpb2RSZXNldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9jYWNoZS9mcmVzaG5lc3MvdHJhbnNmb3JtZXJzL1VzYWdlUGVyaW9kUmVzZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkNBQTBGO0FBRTFGLGlFQUEyRDtBQUMzRCxpRkFBOEU7QUFFOUU7Ozs7R0FJRztBQUNILE1BQWEsZ0JBQWdCO0lBQzNCLFNBQVMsQ0FBQyxZQUE2QjtRQUNyQyxNQUFNLEdBQUcsR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ3ZCLE1BQU0sTUFBTSxHQUFHLDBCQUFlLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFdkMsS0FBSyxNQUFNLFdBQVcsSUFBSSxZQUFZLENBQUMsTUFBTSxFQUFFLEVBQUU7WUFDL0MsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsb0JBQW9CLENBQUMsV0FBVyxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUM7U0FDekQ7UUFFRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRU8sb0JBQW9CLENBQUMsV0FBOEIsRUFBRSxHQUFTOztRQUNwRSxJQUFJLENBQUMsSUFBQSwrQkFBb0IsRUFBQyxXQUFXLENBQUMsRUFBRTtZQUN0QyxPQUFPLFdBQVcsQ0FBQztTQUNwQjtRQUVELE1BQU0sRUFBRSxxQkFBcUIsRUFBRSxTQUFTLEVBQUUsR0FBRyxXQUFXLENBQUM7UUFFekQsTUFBTSxhQUFhLEdBQ2pCLElBQUEsd0JBQVMsRUFBQyxxQkFBcUIsQ0FBQyxPQUFPLENBQUMsSUFBSSxTQUFTLENBQUMsY0FBYyxJQUFJLFNBQVMsQ0FBQyxjQUFjLEdBQUcsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBRW5ILElBQUksQ0FBQyxhQUFhLEVBQUU7WUFDbEIsT0FBTyxXQUFXLENBQUM7U0FDcEI7UUFFRCxNQUFNLEVBQUUsV0FBVyxFQUFFLGlCQUFpQixFQUFFLEdBQUcscUJBQXFCLENBQUM7UUFFakUsSUFBSSxnQkFBa0MsQ0FBQztRQUN2QyxJQUFJLGNBQWdDLENBQUM7UUFFckMsSUFBSSxpQkFBaUIsSUFBSSxXQUFXLEVBQUU7WUFDcEMsQ0FBQyxFQUFFLGdCQUFnQixFQUFFLGNBQWMsRUFBRSxHQUFHLElBQUEsMkNBQW9CLEVBQUMsSUFBSSxJQUFJLENBQUMsaUJBQWlCLENBQUMsRUFBRSxHQUFHLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQztTQUM5RztRQUVELE9BQU8sSUFBSSw0QkFBaUIsQ0FBQyxxQkFBcUIsRUFBRTtZQUNsRCxZQUFZLEVBQUUsQ0FBQztZQUNmLGdCQUFnQixFQUFFLE1BQUEsZ0JBQWdCLGFBQWhCLGdCQUFnQix1QkFBaEIsZ0JBQWdCLENBQUUsT0FBTyxFQUFFLG1DQUFJLElBQUk7WUFDckQsY0FBYyxFQUFFLE1BQUEsY0FBYyxhQUFkLGNBQWMsdUJBQWQsY0FBYyxDQUFFLE9BQU8sRUFBRSxtQ0FBSSxJQUFJO1NBQ2xELENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQXpDRCw0Q0F5Q0MifQ==

package/dist/services/cache/inMemoryCacheService.d.ts

@@ -1,23 +1,28 @@
-import { CacheService, UpdateCreditBalancePayload, UpdateFeatureUsagePayload } from './cacheService';
-import CachedEntitlement from './cachedEntitlement';
-import { EntitlementResponse, EntitlementsResponse } from '../entitlementsService.utils';
-import { CacheInstrumentation } from '../cacheInstrumentation';
-import { AccessDeniedReason } from '../../models';
+import { CacheService } from './cacheService';
+import { CustomerIdentity, SetCustomerParams, GetCustomerEntitlementParams, UpdateUsageParams } from './types/cacheServiceParams';
+import { EntitlementType, EntitlementsMap } from './entities';
+import { CacheMapper } from './CacheMapper';
+import { OneOrMany } from '../../types';
+import { EntitlementResponse, EntitlementsResponse } from './types/cacheResponse';
+import { CacheInstrumentation } from './types/cacheInstrumentation';
+import { AccessDeniedReason } from '@stigg/api-client-js/src/generated/sdk';
 export declare function getApproxSizeBytes(obj: any): number;
 export type CachedCustomerEntitlements = {
-    entitlements: Map<string, CachedEntitlement>;
+    entitlements: EntitlementsMap;
     accessDeniedReason: AccessDeniedReason | null;
 };
-export declare class InMemoryCacheService implements CacheService {
+export declare class InMemoryCacheService<Input> implements CacheService<Input> {
     private readonly instrumentation;
+    private readonly cacheMapper;
     private readonly entitlements;
-    constructor(maxSizeBytes: number, instrumentation: CacheInstrumentation);
+    private readonly freshen;
+    constructor(maxSizeBytes: number, instrumentation: CacheInstrumentation, cacheMapper: CacheMapper<Input>);
     waitForInitialization(): Promise<void>;
     clearCache: () => void;
-    setCustomer(customerId: string, customerEntitlements: Map<string, CachedEntitlement>, accessDeniedReason: AccessDeniedReason | null, resourceId: string | undefined): void;
-    clearCustomer(customerId: string, resourceId: string | undefined): void;
-    getCustomerEntitlements(customerId: string, resourceId: string | undefined): EntitlementsResponse;
-    updateFeatureUsage({ customerId, featureId, currentUsage, resourceId, usagePeriodStart, usagePeriodEnd, }: UpdateFeatureUsagePayload): boolean | Promise<boolean>;
-    getCustomerEntitlement(featureId: string, customerId: string, resourceId: string | undefined): EntitlementResponse;
-    updateEntitlementsBasedOnCreditBalanceUpdate({ customerId, resourceId, currencyId, currentBalance, validUntil, }: UpdateCreditBalancePayload): void;
+    setCustomer({ customerId, resourceId, entitlements: entitlementsInput, accessDeniedReason, }: SetCustomerParams<Input>): EntitlementsMap;
+    purge(customers: OneOrMany<CustomerIdentity>): void;
+    getCustomerEntitlements({ customerId, resourceId }: CustomerIdentity): EntitlementsResponse;
+    updateUsage<T extends EntitlementType>({ customerId, resourceId, entitlementReference, usage, }: UpdateUsageParams<T>): void;
+    getCustomerEntitlement<T extends EntitlementType>(params: GetCustomerEntitlementParams<T>): EntitlementResponse<T>;
+    private getCached;
 }