@stigg/node-server-sdk 4.10.0 → 4.12.0

package/dist/services/cache/types/cacheInstrumentation.d.ts

@@ -0,0 +1,37 @@
+import { Maybe } from '../../../types';
+/**
+ * Data for cache hit tracking.
+ */
+export interface CacheHit {
+    customerId: string;
+    resourceId?: Maybe<string>;
+}
+/**
+ * Data for cache miss tracking.
+ */
+export interface CacheMiss extends CacheHit {
+    globalCustomerMissing?: boolean;
+}
+/**
+ * Data for Redis client error tracking.
+ */
+export interface RedisClientErrorData {
+    error: Error;
+    clientName: string;
+}
+/**
+ * Interface for cache instrumentation/metrics.
+ * Supports both read operations (trackHit/trackMiss) and write operations (trackWriteDuration/trackWriteError).
+ */
+export interface CacheInstrumentation {
+    /** Track a cache hit for a customer lookup */
+    trackHit?(data: CacheHit): void;
+    /** Track a cache miss for a customer lookup */
+    trackMiss?(data: CacheMiss): void;
+    /** Track Redis client connection or operation errors */
+    trackRedisClientError?(data: RedisClientErrorData): void;
+    /** Track the duration of a write operation */
+    trackWriteDuration?(operation: string, durationSeconds: number): void;
+    /** Track write operation errors */
+    trackWriteError?(operation: string): void;
+}

package/dist/services/cache/types/cacheInstrumentation.js

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

package/dist/services/cache/types/cacheResponse.d.ts

@@ -0,0 +1,26 @@
+import { CachedEntitlement, EntitlementType, EntitlementsMap } from '../entities';
+import { AccessDeniedReason } from '@stigg/api-client-js/src/generated/sdk';
+export declare const DATE_IN_FAR_PAST: Date;
+export type EntitlementsResponseCacheHit = {
+    cacheMiss: false;
+    entitlements: EntitlementsMap;
+    accessDeniedReason: AccessDeniedReason | null;
+    globalCustomerMissing: false;
+};
+export type EntitlementsResponseCacheMiss = {
+    cacheMiss: true;
+    entitlements: null;
+    accessDeniedReason: null;
+    globalCustomerMissing: boolean;
+};
+export type EntitlementsResponse = EntitlementsResponseCacheHit | EntitlementsResponseCacheMiss;
+export type EntitlementResponse<T extends EntitlementType = EntitlementType> = {
+    cacheMiss: boolean;
+    accessDeniedReason: AccessDeniedReason | null;
+    entitlement: CachedEntitlement<T> | null;
+    globalCustomerMissing: boolean;
+};
+export declare const entitlementsResponseMapper: {
+    cacheHit: (entitlements: EntitlementsMap, accessDeniedReason: AccessDeniedReason | null) => EntitlementsResponseCacheHit;
+    cacheMiss: (globalCustomerMissing?: boolean) => EntitlementsResponseCacheMiss;
+};

package/dist/services/cache/types/cacheResponse.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entitlementsResponseMapper = exports.DATE_IN_FAR_PAST = void 0;
+exports.DATE_IN_FAR_PAST = new Date(0);
+exports.entitlementsResponseMapper = {
+    cacheHit: (entitlements, accessDeniedReason) => ({
+        cacheMiss: false,
+        entitlements,
+        accessDeniedReason,
+        globalCustomerMissing: false,
+    }),
+    cacheMiss: (globalCustomerMissing = false) => ({
+        cacheMiss: true,
+        entitlements: null,
+        accessDeniedReason: null,
+        globalCustomerMissing,
+    }),
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVSZXNwb25zZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9jYWNoZS90eXBlcy9jYWNoZVJlc3BvbnNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdhLFFBQUEsZ0JBQWdCLEdBQUcsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUF5Qi9CLFFBQUEsMEJBQTBCLEdBQUc7SUFDeEMsUUFBUSxFQUFFLENBQ1IsWUFBNkIsRUFDN0Isa0JBQTZDLEVBQ2YsRUFBRSxDQUFDLENBQUM7UUFDbEMsU0FBUyxFQUFFLEtBQUs7UUFDaEIsWUFBWTtRQUNaLGtCQUFrQjtRQUNsQixxQkFBcUIsRUFBRSxLQUFLO0tBQzdCLENBQUM7SUFDRixTQUFTLEVBQUUsQ0FBQyxxQkFBcUIsR0FBRyxLQUFLLEVBQWlDLEVBQUUsQ0FBQyxDQUFDO1FBQzVFLFNBQVMsRUFBRSxJQUFJO1FBQ2YsWUFBWSxFQUFFLElBQUk7UUFDbEIsa0JBQWtCLEVBQUUsSUFBSTtRQUN4QixxQkFBcUI7S0FDdEIsQ0FBQztDQUNILENBQUMifQ==

package/dist/services/cache/types/cacheServiceParams.d.ts

@@ -0,0 +1,20 @@
+import { EntitlementsStateAccessDeniedReason } from '@stigg/api-client-js/src/generated/sdk';
+import { EntitlementQuery, EntitlementType, UsageData } from '../entities';
+import { Maybe } from '../../../types';
+export type CustomerIdentity = {
+    customerId: string;
+    resourceId: Maybe<string>;
+};
+export type SetCustomerParams<T> = CustomerIdentity & {
+    entitlements: T[];
+    accessDeniedReason: Maybe<EntitlementsStateAccessDeniedReason>;
+    entitlementsTimestamp: number;
+};
+export type GetCustomerEntitlementParams<T extends EntitlementType = EntitlementType> = CustomerIdentity & {
+    query: EntitlementQuery<T>;
+};
+export type UpdateUsageParams<T extends EntitlementType = EntitlementType> = CustomerIdentity & {
+    entitlementReference: EntitlementQuery<T>;
+    usage: UsageData;
+    usageTimestamp: Date;
+};

package/dist/services/cache/types/cacheServiceParams.js

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

package/dist/services/cache/types/entitlementFeature.d.ts

@@ -0,0 +1,19 @@
+import { FeatureType, MeterType, UnitTransformationRound } from '@stigg/api-client-js/src/generated/sdk';
+export type UnitTransformation = {
+    divide: number;
+    round: UnitTransformationRound;
+};
+export type EntitlementFeature = {
+    id: string;
+    displayName: string;
+    description?: string;
+    featureType: FeatureType;
+    meterType?: MeterType;
+    units?: string;
+    unitsPlural?: string;
+    unitTransformation?: UnitTransformation;
+};
+export type EntitlementCreditRate = {
+    amount: number;
+    currencyId: string;
+};

package/dist/services/cache/types/entitlementFeature.js

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

package/dist/services/cache/types/entitlementsMapTransformer.d.ts

@@ -0,0 +1,4 @@
+import { EntitlementsMap } from '../entities';
+export interface EntitlementsMapTransformer {
+    transform(entitlements: EntitlementsMap): EntitlementsMap;
+}

package/dist/services/cache/types/entitlementsMapTransformer.js

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

package/dist/services/cache/types/logger.d.ts

@@ -0,0 +1,6 @@
+export type LoggerExtra = Record<string, any> | Error | Error['stack'];
+export interface SlimLogger {
+    log: (message: string, object?: LoggerExtra) => void;
+    debug: (message: string, object?: LoggerExtra) => void;
+    error: (message: string, error?: LoggerExtra) => void;
+}

package/dist/services/cache/types/logger.js

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

package/dist/services/cache/types/redisConfiguration.d.ts

@@ -0,0 +1,39 @@
+import { RedisOptions } from 'ioredis/built/redis/RedisOptions';
+import { Settings } from 'redlock';
+/**
+ * Cache update policy that controls how the cache handles write operations.
+ */
+export declare enum CacheUpdatePolicy {
+    /** Always write to cache, creating new entries if they don't exist (default) */
+    UPSERT = "UPSERT",
+    /** Only update existing cache entries, skip if the key doesn't exist */
+    UPDATE_IF_EXISTS = "UPDATE_IF_EXISTS"
+}
+export type DistributedEntitlementsFetchingOptions = {
+    /** Whether to disable the distributed entitlements fetching mechanism */
+    disabled?: boolean;
+    /**
+     * The buffer in milliseconds for waiting for notification from other instance.
+     */
+    notificationBufferMs?: number;
+};
+export type StiggRedisOptions = RedisOptions & {
+    /** A prefix used in all Redis interactions to distinguish between different environments operating on the same Redis database */
+    environmentPrefix: string;
+    /** The TTL of data stored in Redis */
+    ttl?: number;
+    /** Configuration of the distributed entitlements fetching in case of a cache miss */
+    distributedEntitlementsFetching?: DistributedEntitlementsFetchingOptions;
+};
+export type LockSettings = Pick<Settings, 'retryCount' | 'retryDelay' | 'retryJitter'>;
+export type RedisCacheConfiguration = {
+    redis: StiggRedisOptions;
+    /** Timeout for entitlements fetching in milliseconds. Defaults to 30000 (30 seconds). */
+    entitlementsTimeout?: number;
+    /** Cache update policy. Defaults to UPSERT. */
+    cacheUpdatePolicy?: CacheUpdatePolicy;
+    /** Settings for distributed lock acquisition. */
+    lockSettings?: LockSettings;
+    /** When true, operations run directly without safety wrapper (no connection check, errors propagate). Defaults to false. */
+    directExecution?: boolean;
+};

package/dist/services/cache/types/redisConfiguration.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheUpdatePolicy = void 0;
+/**
+ * Cache update policy that controls how the cache handles write operations.
+ */
+var CacheUpdatePolicy;
+(function (CacheUpdatePolicy) {
+    /** Always write to cache, creating new entries if they don't exist (default) */
+    CacheUpdatePolicy["UPSERT"] = "UPSERT";
+    /** Only update existing cache entries, skip if the key doesn't exist */
+    CacheUpdatePolicy["UPDATE_IF_EXISTS"] = "UPDATE_IF_EXISTS";
+})(CacheUpdatePolicy = exports.CacheUpdatePolicy || (exports.CacheUpdatePolicy = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVkaXNDb25maWd1cmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2NhY2hlL3R5cGVzL3JlZGlzQ29uZmlndXJhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQTs7R0FFRztBQUNILElBQVksaUJBTVg7QUFORCxXQUFZLGlCQUFpQjtJQUMzQixnRkFBZ0Y7SUFDaEYsc0NBQWlCLENBQUE7SUFFakIsd0VBQXdFO0lBQ3hFLDBEQUFxQyxDQUFBO0FBQ3ZDLENBQUMsRUFOVyxpQkFBaUIsR0FBakIseUJBQWlCLEtBQWpCLHlCQUFpQixRQU01QiJ9

package/dist/services/entitlementDecisionService.d.ts

@@ -1,7 +1,19 @@
-import CachedEntitlement from './cache/cachedEntitlement';
+import { CachedEntitlement, EntitlementType } from './cache';
 import { AccessDeniedReason } from '../models';
+import { Maybe } from '../types';
+export interface DecideEntitlementPolicyParams {
+    entitlementType: EntitlementType;
+    accessDeniedReason: Maybe<AccessDeniedReason>;
+    entitlement: Maybe<CachedEntitlement>;
+    requestedUsage?: number;
+    requestedValues?: string[];
+}
 export declare class EntitlementDecisionService {
-    static decideEntitlementPolicy(accessDeniedReason?: AccessDeniedReason | null, entitlement?: CachedEntitlement | null, requestUsage?: number, requestedValues?: string[]): Decision;
+    static decideEntitlementPolicy({ entitlementType, accessDeniedReason, entitlement, requestedUsage, requestedValues, }: DecideEntitlementPolicyParams): Decision;
+    private static getNotFoundReason;
+    private static decideFeatureAccess;
+    private static decideCreditAccess;
+    private static decideUsageBasedAccess;
 }
 export interface Decision {
     readonly hasAccess: boolean;

package/dist/services/entitlementDecisionService.js

@@ -1,22 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntitlementDecisionService = void 0;
+const cache_1 = require("./cache");
 const models_1 = require("../models");
 const lodash_1 = require("lodash");
 // TODO: Extract to a common lib for other sdks
 class EntitlementDecisionService {
-    static decideEntitlementPolicy(accessDeniedReason, entitlement, requestUsage = 0, requestedValues = []) {
-        var _a;
+    static decideEntitlementPolicy({ entitlementType, accessDeniedReason, entitlement, requestedUsage = 0, requestedValues = [], }) {
         if (accessDeniedReason) {
             return { accessDeniedReason: accessDeniedReason, hasAccess: false };
         }
-        if (!entitlement || !entitlement.calculatedEntitlement.feature) {
-            return { hasAccess: false, accessDeniedReason: models_1.AccessDeniedReason.NoFeatureEntitlementInSubscription };
+        if (!entitlement) {
+            return { hasAccess: false, accessDeniedReason: this.getNotFoundReason(entitlementType) };
         }
         if (entitlement.calculatedEntitlement.accessDeniedReason) {
             return { hasAccess: false, accessDeniedReason: entitlement.calculatedEntitlement.accessDeniedReason };
         }
-        const { featureType, meterType } = entitlement.calculatedEntitlement.feature;
+        if ((0, cache_1.isCreditEntitlement)(entitlement)) {
+            return this.decideCreditAccess(entitlement);
+        }
+        if ((0, cache_1.isFeatureEntitlement)(entitlement)) {
+            return this.decideFeatureAccess(entitlement, requestedUsage, requestedValues);
+        }
+        return { hasAccess: false, accessDeniedReason: models_1.AccessDeniedReason.NoFeatureEntitlementInSubscription };
+    }
+    static getNotFoundReason(entitlementType) {
+        if (entitlementType === cache_1.EntitlementType.Feature) {
+            // for backward compatability
+            return models_1.AccessDeniedReason.NoFeatureEntitlementInSubscription;
+        }
+        return models_1.AccessDeniedReason.EntitlementNotFound;
+    }
+    static decideFeatureAccess(entitlement, requestUsage, requestedValues) {
+        const { feature } = entitlement.calculatedEntitlement;
+        const { featureType, meterType } = feature;
         switch (featureType) {
             case models_1.FeatureType.Boolean:
                 return { hasAccess: true };
@@ -37,17 +54,27 @@ class EntitlementDecisionService {
                 if (entitlement.calculatedEntitlement.hasUnlimitedUsage || entitlement.calculatedEntitlement.hasSoftLimit) {
                     return { hasAccess: true };
                 }
-                const usageLimit = ((_a = entitlement.calculatedEntitlement) === null || _a === void 0 ? void 0 : _a.usageLimit) || 0;
-                const currentUsage = entitlement.featureUsage.currentUsage;
-                if (currentUsage + requestUsage <= usageLimit) {
-                    return { hasAccess: true };
-                }
-                else {
-                    return { hasAccess: false, accessDeniedReason: models_1.AccessDeniedReason.RequestedUsageExceedingLimit };
-                }
+                const usageLimit = entitlement.calculatedEntitlement.usageLimit || 0;
+                const currentUsage = entitlement.usageData.currentUsage;
+                return this.decideUsageBasedAccess(usageLimit, currentUsage, requestUsage);
             }
         }
     }
+    static decideCreditAccess(entitlement) {
+        const { usageLimit } = entitlement.calculatedEntitlement;
+        const { currentUsage } = entitlement.usageData;
+        // checking at least 1 credit to deny access when none remaining
+        const requestUsage = 1;
+        return this.decideUsageBasedAccess(usageLimit, currentUsage, requestUsage);
+    }
+    static decideUsageBasedAccess(usageLimit, currentUsage, requestUsage) {
+        if (currentUsage + requestUsage <= usageLimit) {
+            return { hasAccess: true };
+        }
+        else {
+            return { hasAccess: false, accessDeniedReason: models_1.AccessDeniedReason.RequestedUsageExceedingLimit };
+        }
+    }
 }
 exports.EntitlementDecisionService = EntitlementDecisionService;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXRsZW1lbnREZWNpc2lvblNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvZW50aXRsZW1lbnREZWNpc2lvblNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0Esc0NBQXVFO0FBQ3ZFLG1DQUE2QztBQUU3QywrQ0FBK0M7QUFDL0MsTUFBYSwwQkFBMEI7SUFDOUIsTUFBTSxDQUFDLHVCQUF1QixDQUNuQyxrQkFBOEMsRUFDOUMsV0FBc0MsRUFDdEMsWUFBWSxHQUFHLENBQUMsRUFDaEIsa0JBQTRCLEVBQUU7O1FBRTlCLElBQUksa0JBQWtCLEVBQUU7WUFDdEIsT0FBTyxFQUFFLGtCQUFrQixFQUFFLGtCQUFrQixFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsQ0FBQztTQUNyRTtRQUNELElBQUksQ0FBQyxXQUFXLElBQUksQ0FBQyxXQUFXLENBQUMscUJBQXFCLENBQUMsT0FBTyxFQUFFO1lBQzlELE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLGtCQUFrQixFQUFFLDJCQUFrQixDQUFDLGtDQUFrQyxFQUFFLENBQUM7U0FDeEc7UUFFRCxJQUFJLFdBQVcsQ0FBQyxxQkFBcUIsQ0FBQyxrQkFBa0IsRUFBRTtZQUN4RCxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxXQUFXLENBQUMscUJBQXFCLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztTQUN2RztRQUVELE1BQU0sRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLEdBQUcsV0FBVyxDQUFDLHFCQUFxQixDQUFDLE9BQU8sQ0FBQztRQUU3RSxRQUFRLFdBQVcsRUFBRTtZQUNuQixLQUFLLG9CQUFXLENBQUMsT0FBTztnQkFDdEIsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQztZQUM3QixLQUFLLG9CQUFXLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ3JCLE1BQU0sYUFBYSxHQUFHLElBQUEsbUJBQVUsRUFBQyxlQUFlLEVBQUUsV0FBVyxDQUFDLHFCQUFxQixDQUFDLFVBQVUsSUFBSSxFQUFFLENBQUMsQ0FBQztnQkFDdEcsSUFBSSxDQUFDLElBQUEsZ0JBQU8sRUFBQyxhQUFhLENBQUMsRUFBRTtvQkFDM0IsT0FBTzt3QkFDTCxTQUFTLEVBQUUsS0FBSzt3QkFDaEIsa0JBQWtCLEVBQUUsMkJBQWtCLENBQUMsdUJBQXVCO3FCQUMvRCxDQUFDO2lCQUNIO2dCQUNELE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUM7YUFDNUI7WUFDRCxLQUFLLG9CQUFXLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQ3ZCLElBQUksU0FBUyxLQUFLLGtCQUFTLENBQUMsSUFBSSxFQUFFO29CQUNoQyxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDO2lCQUM1QjtnQkFDRCxJQUFJLFdBQVcsQ0FBQyxxQkFBcUIsQ0FBQyxpQkFBaUIsSUFBSSxXQUFXLENBQUMscUJBQXFCLENBQUMsWUFBWSxFQUFFO29CQUN6RyxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDO2lCQUM1QjtnQkFFRCxNQUFNLFVBQVUsR0FBRyxDQUFBLE1BQUEsV0FBVyxDQUFDLHFCQUFxQiwwQ0FBRSxVQUFVLEtBQUksQ0FBQyxDQUFDO2dCQUN0RSxNQUFNLFlBQVksR0FBRyxXQUFXLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQztnQkFFM0QsSUFBSSxZQUFZLEdBQUcsWUFBWSxJQUFJLFVBQVUsRUFBRTtvQkFDN0MsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQztpQkFDNUI7cUJBQU07b0JBQ0wsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsMkJBQWtCLENBQUMsNEJBQTRCLEVBQUUsQ0FBQztpQkFDbEc7YUFDRjtTQUNGO0lBQ0gsQ0FBQztDQUNGO0FBcERELGdFQW9EQyJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/entitlementsService.d.ts

@@ -1,36 +1,35 @@
 import EntitlementsApi from '../api/entitlements/entitlementsApi';
 import { LoggerService } from './loggerService';
 import { ApolloClient, FetchResult, NormalizedCacheObject } from '@apollo/client/core';
-import { BooleanEntitlement, BooleanEntitlementOptions, CreateUsageMeasurement, Entitlement, EnumEntitlement, EnumEntitlementOptions, MeteredEntitlement, MeteredEntitlementOptions, NumericEntitlement, NumericEntitlementOptions, ReportEvent } from '../models';
+import { BooleanEntitlement, BooleanEntitlementOptions, CreateUsageMeasurement, CreditEntitlement, Entitlement, EnumEntitlement, EnumEntitlementOptions, MeteredEntitlement, MeteredEntitlementOptions, NumericEntitlement, NumericEntitlementOptions, ReportEvent } from '../models';
 import { ModelMapper } from '../utils/ModelMapper';
-import { CacheService } from './cache/cacheService';
+import { CacheService, EntitlementsMap, AccessDeniedReason, EntitlementsStateAccessDeniedReason } from './cache';
+import { Maybe } from '../types';
 import { EdgeApiClient } from './EdgeApiClient';
-import { AccessDeniedReason, EntitlementFragment, EntitlementsStateAccessDeniedReason, ReportEventMutation, ReportUsageBulkInput, ReportUsageBulkMutation, ReportUsageFragment, ReportUsageMutation } from '@stigg/api-client-js/src/generated/sdk';
-import CacheMapper from '../utils/CacheMapper';
-import { EntitlementsResponse, EntitlementsResponseCacheHit, RefetchEntitlementsAfterCacheMissParams, RefetchEntitlementsParams, RefetchEntityEntitlementsAfterCacheMissParams } from './entitlementsService.utils';
-import CachedEntitlement from './cache/cachedEntitlement';
-export declare const accessDeniedReasonMap: Record<EntitlementsStateAccessDeniedReason, AccessDeniedReason>;
+import { EntitlementUnionFragment, ReportEventMutation, ReportUsageBulkInput, ReportUsageBulkMutation, ReportUsageFragment, ReportUsageMutation } from '@stigg/api-client-js/src/generated/sdk';
+import { EntitlementsResponse, EntitlementsResponseCacheHit } from './cache';
+import { RefetchEntitlementsAfterCacheMissParams, RefetchEntitlementsParams, RefetchEntityEntitlementsAfterCacheMissParams } from './entitlementsService.utils';
+import { CacheableEntitlement } from './ApiCacheMapper';
 export interface CustomerEntitlementsResult {
     entitlements: Entitlement[];
     accessDeniedReason: AccessDeniedReason | null;
 }
 export declare abstract class EntitlementsService {
     protected readonly loggerService: LoggerService;
-    protected readonly cacheService: CacheService;
+    protected readonly cacheService: CacheService<CacheableEntitlement>;
     private readonly entitlementsTimeout;
     protected readonly entitlementsApi: EntitlementsApi;
     protected readonly modelMapper: ModelMapper;
-    protected readonly cacheMapper: CacheMapper;
     protected isInitialized: boolean;
-    protected constructor(client: ApolloClient<NormalizedCacheObject>, loggerService: LoggerService, edgeApiClient: EdgeApiClient | null, cacheService: CacheService, entitlementsTimeout: number);
-    getBooleanEntitlement(customerRefId: string, featureRefId: string, fallbackEntitlement: BooleanEntitlement, resourceId?: string, options?: BooleanEntitlementOptions): Promise<BooleanEntitlement>;
-    getNumericEntitlement(customerRefId: string, featureRefId: string, fallbackEntitlement: NumericEntitlement, resourceId?: string, options?: NumericEntitlementOptions): Promise<NumericEntitlement>;
-    getMeteredEntitlement(customerRefId: string, featureRefId: string, fallbackEntitlement: MeteredEntitlement, resourceId?: string, options?: MeteredEntitlementOptions): Promise<MeteredEntitlement>;
-    getEnumEntitlement(customerRefId: string, featureRefId: string, fallbackEntitlement: EnumEntitlement, resourceId?: string, options?: EnumEntitlementOptions): Promise<EnumEntitlement>;
-    getEntitlement(customerRefId: string, featureRefId: string, fallbackEntitlement: Entitlement, resourceId?: string, requestedUsage?: number, requestedValues?: string[]): Promise<Entitlement>;
-    private handleUsagePeriodOver;
+    protected constructor(client: ApolloClient<NormalizedCacheObject>, loggerService: LoggerService, edgeApiClient: EdgeApiClient | null, cacheService: CacheService<CacheableEntitlement>, entitlementsTimeout: number);
+    getBooleanEntitlement(customerId: string, featureRefId: string, fallbackEntitlement: BooleanEntitlement, resourceId?: string, options?: BooleanEntitlementOptions): Promise<BooleanEntitlement>;
+    getNumericEntitlement(customerId: string, featureRefId: string, fallbackEntitlement: NumericEntitlement, resourceId?: string, options?: NumericEntitlementOptions): Promise<NumericEntitlement>;
+    getMeteredEntitlement(customerId: string, featureRefId: string, fallbackEntitlement: MeteredEntitlement, resourceId?: string, options?: MeteredEntitlementOptions): Promise<MeteredEntitlement>;
+    getEnumEntitlement(customerId: string, featureRefId: string, fallbackEntitlement: EnumEntitlement, resourceId?: string, options?: EnumEntitlementOptions): Promise<EnumEntitlement>;
+    getCreditEntitlement(customerId: string, currencyId: string, resourceId?: string): Promise<CreditEntitlement>;
+    getEntitlement(customerId: string, featureRefId: string, fallbackEntitlement: Entitlement, resourceId?: string, requestedUsage?: number, requestedValues?: string[]): Promise<Entitlement>;
     private getCustomerAndEntitlementFromCacheOrRefetch;
-    getCustomerEntitlements(customerRefId: string, resourceId: string | undefined): Promise<CustomerEntitlementsResult>;
+    getCustomerEntitlements(customerId: string, resourceId: string | undefined): Promise<CustomerEntitlementsResult>;
     abstract clearCache(): void | Promise<void>;
     abstract init(): void | Promise<void>;
     abstract cleanup(): void | Promise<void>;
@@ -41,17 +40,21 @@ export declare abstract class EntitlementsService {
     protected abstract refetchEntityEntitlementsAfterCacheMiss(params: RefetchEntityEntitlementsAfterCacheMissParams): Promise<EntitlementsResponse>;
     refetchEntitlements({ customerId, resourceId, skipEdge, triggeredBy, }: RefetchEntitlementsParams): Promise<EntitlementsResponseCacheHit>;
     setEntitlementsIfExists(options: {
-        entitlements?: EntitlementFragment[] | null;
+        entitlements?: EntitlementUnionFragment[] | null;
         customerId: string;
         resourceId: string | undefined;
-    }): Promise<Map<string, CachedEntitlement> | null>;
+    }): Promise<EntitlementsMap | null>;
     setEntitlements(params: {
-        entitlements: EntitlementFragment[];
-        accessDeniedReason: AccessDeniedReason | null;
+        entitlements: EntitlementUnionFragment[];
+        accessDeniedReason: Maybe<EntitlementsStateAccessDeniedReason>;
         customerId: string;
         resourceId: string | undefined;
-    }): Promise<Map<string, CachedEntitlement>>;
-    private getEntitlementsUpdatedAtTimestamp;
+    }): Promise<EntitlementsMap>;
+    protected getEntitlementsUpdatedAtTimestamp({ entitlements, customerId, resourceId, }: {
+        entitlements: EntitlementUnionFragment[];
+        customerId: string;
+        resourceId: Maybe<string>;
+    }): Date;
     updateFeatureUsage({ featureId, customerId, resourceId, currentUsage, usagePeriodStart, usagePeriodEnd, timestamp, }: ReportUsageFragment): Promise<void>;
     waitForInitialization(): Promise<void>;
     private isEntitlementExpired;