@stigg/node-server-sdk 0.18.1

package/dist/client.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stigg = void 0;
+const models_1 = require("./models");
+const initApolloClient_1 = __importDefault(require("./api/initApolloClient"));
+const ModelMapper_1 = require("./utils/ModelMapper");
+const managementApi_1 = __importDefault(require("./api/managementApi"));
+const configuration_1 = require("./configuration");
+const configurationApi_1 = __importDefault(require("./api/configurationApi"));
+const inMemoryCacheService_1 = require("./services/cache/inMemoryCacheService");
+const entitlementsService_1 = require("./services/entitlementsService");
+const loggerService_1 = require("./services/loggerService");
+function meow(num) {
+    if (num === 1) {
+        return {
+            abc: 1,
+            zubi: 'wuff',
+        };
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Stigg SDK client
+ */
+class Stigg {
+    /**
+     * Create an instance of the Stigg SDK client.
+     * @param graphClient
+     * @param entitlementsCacheService
+     * @param loggerService
+     * @param environmentId
+     */
+    constructor(graphClient, entitlementsCacheService, loggerService, environmentId) {
+        this.graphqlClient = graphClient;
+        this.modelMapper = new ModelMapper_1.ModelMapper();
+        this.cacheService = entitlementsCacheService;
+        this.loggerService = loggerService;
+        this.entitlementsService = new entitlementsService_1.EntitlementsService(this.cacheService, this.graphqlClient, this.loggerService);
+        this.managementApi = new managementApi_1.default(this.graphqlClient, environmentId);
+    }
+    /**
+     * Initialize an instance of the Stigg SDK client.
+     * @param {Partial<ClientConfiguration>} configuration - client configuration object provided by the consumer.
+     */
+    static async initialize(configuration) {
+        try {
+            (0, configuration_1.validateConfiguration)(configuration);
+            const sdkConfiguration = (0, configuration_1.getConfiguration)(configuration);
+            const loggerService = new loggerService_1.LoggerService(sdkConfiguration.logConfiguration.logger, sdkConfiguration.logConfiguration.logLevel);
+            const entitlementsCacheService = new inMemoryCacheService_1.InMemoryCacheService();
+            const graphqlClient = (0, initApolloClient_1.default)(Object.assign(Object.assign({}, sdkConfiguration), { onConnected: entitlementsCacheService.clearCache, loggerService }));
+            const configurationApi = new configurationApi_1.default(graphqlClient);
+            const environmentId = (await configurationApi.getEnvironment()).data.currentEnvironment;
+            return new Stigg(graphqlClient, entitlementsCacheService, loggerService, environmentId);
+        }
+        catch (err) {
+            throw new Error(`Failed to initialize api ${err}`);
+        }
+    }
+    /**
+     * Fetch a specific boolean Entitlement.
+     * @return {Promise<boolean>} List of features.
+     */
+    async getEntitlement(featureRefId, customerRefId, options) {
+        try {
+            const entitlement = await this.entitlementsService.getEntitlement(featureRefId, customerRefId, options === null || options === void 0 ? void 0 : options.requestedUsage);
+            if (!entitlement) {
+                return this.handleNoEntitlementFound(options === null || options === void 0 ? void 0 : options.fallbackGrantedValue);
+            }
+            return entitlement;
+        }
+        catch (err) {
+            this.loggerService.error(`Failed to get entitlement: ${JSON.stringify(err.graphQLErrors['0'].extensions)}`);
+            return this.handleNoEntitlementFound(options === null || options === void 0 ? void 0 : options.fallbackGrantedValue);
+        }
+    }
+    handleNoEntitlementFound(fallbackGrantedValue) {
+        if (fallbackGrantedValue) {
+            return {
+                isValid: false,
+                isGranted: fallbackGrantedValue,
+                accessDeniedReason: fallbackGrantedValue ? models_1.AccessDeniedReason.Unknown : null,
+            };
+        }
+        return models_1.INVALID_ENTITLEMENT;
+    }
+    async decrement(featureRefId, customerRefId, value = 1) {
+        try {
+            await this.entitlementsService.createUsageMeasurement({
+                featureId: featureRefId,
+                customerId: customerRefId,
+                value: -value,
+            });
+        }
+        catch (err) {
+            this.loggerService.error(`Failed to decrement: ${JSON.stringify(err.graphQLErrors['0'].extensions)}`);
+        }
+    }
+    async increment(featureRefId, customerRefId, value = 1) {
+        try {
+            await this.entitlementsService.createUsageMeasurement({
+                featureId: featureRefId,
+                customerId: customerRefId,
+                value,
+            });
+        }
+        catch (err) {
+            this.loggerService.error(`Failed to increment: ${JSON.stringify(err.graphQLErrors['0'].extensions)}`);
+        }
+    }
+    /**
+     * Create a Customer.
+     * @return {Promise<Customer>} Newly created customer.
+     * @param customerRefId
+     */
+    async createCustomer(customerRefId) {
+        try {
+            const { data } = await this.managementApi.createCustomer(customerRefId);
+            if (!data)
+                throw new Error('Invalid response');
+            return this.modelMapper.mapCustomer(data);
+        }
+        catch (err) {
+            throw new Error(`Failed to create customer: ${err}`);
+        }
+    }
+    /**
+     * Create a Subscription
+     * @return {Promise<Subscription>} Newly created subscription.
+     * @param createSubscription
+     */
+    async createSubscription(createSubscription) {
+        try {
+            const { data } = await this.managementApi.createSubscription(createSubscription);
+            if (!data)
+                throw new Error('Invalid response');
+            return this.modelMapper.mapSubscription(data);
+        }
+        catch (err) {
+            throw new Error(`Failed to create subscription: ${err}`);
+        }
+    }
+    /**
+     * Initiate a checkout to purchase a plan
+     * @return {Promise<Checkout>} Container object for the checkout process.
+     * @param initiateCheckout
+     */
+    async initiateCheckout(initiateCheckout) {
+        try {
+            const { data } = await this.managementApi.initiateCheckout(initiateCheckout);
+            if (!data)
+                throw new Error('Invalid response');
+            return this.modelMapper.mapCheckout(data.initiateCheckout);
+        }
+        catch (err) {
+            throw new Error(`Failed to begin checkout: ${err}`);
+        }
+    }
+}
+exports.Stigg = Stigg;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/configuration.d.ts

@@ -0,0 +1,18 @@
+import { LogLevel } from './services/loggerService';
+export interface Logger {
+    log: (message: string, object?: Record<string, string>) => void;
+    error: (message: string, error?: Record<string, string>) => void;
+}
+export interface LogConfiguration {
+    logger: Logger;
+    logLevel: LogLevel;
+}
+declare type ClientConfiguration = {
+    sdkKey: string;
+    baseUri?: string;
+    wsUrl?: string;
+    logConfiguration?: LogConfiguration;
+};
+declare function getConfiguration(configuration: Partial<ClientConfiguration>): Required<ClientConfiguration>;
+declare function validateConfiguration(configuration: Partial<ClientConfiguration>): void;
+export { getConfiguration, ClientConfiguration, validateConfiguration };

package/dist/configuration.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfiguration = exports.getConfiguration = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const loggerService_1 = require("./services/loggerService");
+const defaults = () => {
+    const baseUri = 'https://api.stigg.io';
+    return {
+        baseUri,
+        wsUrl: getWsUrl(baseUri),
+        logConfiguration: {
+            logger: console,
+            logLevel: loggerService_1.LogLevel.ERROR,
+        },
+    };
+};
+function getConfiguration(configuration) {
+    const defaultConfig = defaults();
+    const wsUrl = configuration.wsUrl
+        ? configuration.wsUrl
+        : configuration.baseUri
+            ? getWsUrl(configuration.baseUri)
+            : defaultConfig.wsUrl;
+    return lodash_1.default.merge(defaultConfig, configuration, { wsUrl });
+}
+exports.getConfiguration = getConfiguration;
+function getWsUrl(apiUrl) {
+    const url = new URL(apiUrl);
+    if (url.protocol === 'http:') {
+        url.protocol = 'ws:';
+    }
+    else if (url.protocol === 'https:') {
+        url.protocol = 'wss:';
+    }
+    // Remove last char since URL.toString() adds a redundant backslash
+    return url.toString().slice(0, -1);
+}
+function validateConfiguration(configuration) {
+    if (!configuration.sdkKey) {
+        throw new Error('You must configure the client with an SDK key');
+    }
+}
+exports.validateConfiguration = validateConfiguration;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb25maWd1cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLG9EQUF1QjtBQUN2Qiw0REFBb0Q7QUFtQnBELE1BQU0sUUFBUSxHQUFHLEdBQWlDLEVBQUU7SUFDbEQsTUFBTSxPQUFPLEdBQUcsc0JBQXNCLENBQUM7SUFDdkMsT0FBTztRQUNMLE9BQU87UUFDUCxLQUFLLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQztRQUN4QixnQkFBZ0IsRUFBRTtZQUNoQixNQUFNLEVBQUUsT0FBTztZQUNmLFFBQVEsRUFBRSx3QkFBUSxDQUFDLEtBQUs7U0FDekI7S0FDRixDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBRUYsU0FBUyxnQkFBZ0IsQ0FBQyxhQUEyQztJQUNuRSxNQUFNLGFBQWEsR0FBRyxRQUFRLEVBQUUsQ0FBQztJQUNqQyxNQUFNLEtBQUssR0FBRyxhQUFhLENBQUMsS0FBSztRQUMvQixDQUFDLENBQUMsYUFBYSxDQUFDLEtBQUs7UUFDckIsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxPQUFPO1lBQ3ZCLENBQUMsQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQztZQUNqQyxDQUFDLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQztJQUV4QixPQUFPLGdCQUFDLENBQUMsS0FBSyxDQUFDLGFBQWEsRUFBRSxhQUFhLEVBQUUsRUFBRSxLQUFLLEVBQUUsQ0FBa0MsQ0FBQztBQUMzRixDQUFDO0FBcUJRLDRDQUFnQjtBQW5CekIsU0FBUyxRQUFRLENBQUMsTUFBYztJQUM5QixNQUFNLEdBQUcsR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUU1QixJQUFJLEdBQUcsQ0FBQyxRQUFRLEtBQUssT0FBTyxFQUFFO1FBQzVCLEdBQUcsQ0FBQyxRQUFRLEdBQUcsS0FBSyxDQUFDO0tBQ3RCO1NBQU0sSUFBSSxHQUFHLENBQUMsUUFBUSxLQUFLLFFBQVEsRUFBRTtRQUNwQyxHQUFHLENBQUMsUUFBUSxHQUFHLE1BQU0sQ0FBQztLQUN2QjtJQUVELG1FQUFtRTtJQUNuRSxPQUFPLEdBQUcsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDckMsQ0FBQztBQUVELFNBQVMscUJBQXFCLENBQUMsYUFBMkM7SUFDeEUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxNQUFNLEVBQUU7UUFDekIsTUFBTSxJQUFJLEtBQUssQ0FBQywrQ0FBK0MsQ0FBQyxDQUFDO0tBQ2xFO0FBQ0gsQ0FBQztBQUUrQyxzREFBcUIifQ==

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { ClientConfiguration } from './configuration';
+export { LogLevel } from './services/loggerService';
+export * from './models';
+export { StiggEntitlementAPI, StiggManagementAPI } from './client';
+import { Stigg } from './client';
+export default Stigg;

package/dist/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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+exports.LogLevel = void 0;
+var loggerService_1 = require("./services/loggerService");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return loggerService_1.LogLevel; } });
+__exportStar(require("./models"), exports);
+const client_1 = require("./client");
+exports.default = client_1.Stigg;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7OztBQUNBLDBEQUFvRDtBQUEzQyx5R0FBQSxRQUFRLE9BQUE7QUFDakIsMkNBQXlCO0FBRXpCLHFDQUFpQztBQUNqQyxrQkFBZSxjQUFLLENBQUMifQ==

package/dist/models.d.ts

@@ -0,0 +1,107 @@
+import { AccessDeniedReason, BillingPeriod } from './api/generated/types';
+export { AccessDeniedReason } from './api/generated/types';
+export { ErrorCode } from './api/generated/types';
+export { BillingPeriod } from './api/generated/types';
+export declare enum FeatureType {
+    Boolean = "BOOLEAN",
+    Number = "NUMBER"
+}
+export declare enum MeterType {
+    Fluctuating = "Fluctuating",
+    Incremental = "Incremental",
+    None = "None"
+}
+export declare type BaseEntitlement = {
+    isValid: boolean;
+    isGranted: boolean;
+    featureType?: FeatureType;
+    accessDeniedReason?: AccessDeniedReason | null;
+    featureId?: string | null;
+};
+export interface InvalidEntitlement extends BaseEntitlement {
+    isValid: false;
+    isGranted: false;
+    accessDeniedReason: AccessDeniedReason.FeatureNotFound | AccessDeniedReason.CustomerNotFound | AccessDeniedReason.Unknown;
+}
+export interface FallbackEntitlement extends BaseEntitlement {
+    isValid: false;
+}
+export interface ValidEntitlement extends BaseEntitlement {
+    isValid: true;
+}
+export interface BooleanEntitlement extends BaseEntitlement {
+    featureType: FeatureType.Boolean;
+}
+export interface NumberEntitlement extends BaseEntitlement {
+    featureType: FeatureType.Number;
+    usageLimit: number | null;
+    featureUnits?: string;
+    featureUnitsPlural?: string;
+    hasUnlimitedUsage: boolean;
+}
+export interface MeteredEntitlement extends NumberEntitlement {
+    featureType: FeatureType.Number;
+    meterType: MeterType.Fluctuating | MeterType.Incremental | MeterType.None;
+    currentUsage: number;
+    requestedUsage: number;
+}
+export declare type Entitlement = FallbackEntitlement | InvalidEntitlement | BooleanEntitlement | NumberEntitlement | MeteredEntitlement;
+export declare const INVALID_ENTITLEMENT: InvalidEntitlement;
+export declare type Customer = {
+    id: string;
+};
+export declare type Subscription = {
+    planId: string;
+    addonIds: string[];
+    customerId: string;
+};
+export declare type SubscriptionAddon = {
+    addonId: string;
+    quantity?: number;
+    billingPeriod: BillingPeriod;
+};
+export declare type CreateSubscription = {
+    customerId: string;
+    planId: string;
+    addons: SubscriptionAddon[];
+    startDate: Date;
+    endDate?: Date;
+    id?: string;
+    billingPeriod: BillingPeriod;
+    unitQuantity?: number;
+    isTrialSubscription?: boolean;
+};
+export declare type EntitlementOptions = {
+    requestedUsage?: number;
+    shouldTrack?: boolean;
+    fallbackGrantedValue?: boolean;
+};
+export declare type FetchEntitlement = {
+    customerId: string;
+    featureId: string;
+    options?: EntitlementOptions;
+};
+export declare type FetchEntitlements = {
+    customerId: string;
+};
+export declare type CreateUsageMeasurement = {
+    customerId: string;
+    featureId: string;
+    value: number;
+};
+export declare type CheckoutAddon = {
+    addonId: string;
+    quantity?: number;
+};
+export declare type InitiateCheckout = {
+    customerId: string;
+    planId: string;
+    addons: CheckoutAddon[];
+    successUrl: string;
+    cancelUrl: string;
+    billingPeriod: BillingPeriod;
+};
+export declare type Checkout = {
+    checkoutBillingId: string;
+    checkoutUrl: string;
+};

package/dist/models.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_ENTITLEMENT = exports.MeterType = exports.FeatureType = exports.BillingPeriod = exports.ErrorCode = exports.AccessDeniedReason = void 0;
+const types_1 = require("./api/generated/types");
+var types_2 = require("./api/generated/types");
+Object.defineProperty(exports, "AccessDeniedReason", { enumerable: true, get: function () { return types_2.AccessDeniedReason; } });
+var types_3 = require("./api/generated/types");
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return types_3.ErrorCode; } });
+var types_4 = require("./api/generated/types");
+Object.defineProperty(exports, "BillingPeriod", { enumerable: true, get: function () { return types_4.BillingPeriod; } });
+var FeatureType;
+(function (FeatureType) {
+    FeatureType["Boolean"] = "BOOLEAN";
+    FeatureType["Number"] = "NUMBER";
+})(FeatureType = exports.FeatureType || (exports.FeatureType = {}));
+var MeterType;
+(function (MeterType) {
+    MeterType["Fluctuating"] = "Fluctuating";
+    MeterType["Incremental"] = "Incremental";
+    MeterType["None"] = "None";
+})(MeterType = exports.MeterType || (exports.MeterType = {}));
+exports.INVALID_ENTITLEMENT = {
+    isValid: false,
+    isGranted: false,
+    accessDeniedReason: types_1.AccessDeniedReason.Unknown,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL21vZGVscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBMEU7QUFFMUUsK0NBQTJEO0FBQWxELDJHQUFBLGtCQUFrQixPQUFBO0FBQzNCLCtDQUFrRDtBQUF6QyxrR0FBQSxTQUFTLE9BQUE7QUFDbEIsK0NBQXNEO0FBQTdDLHNHQUFBLGFBQWEsT0FBQTtBQUV0QixJQUFZLFdBR1g7QUFIRCxXQUFZLFdBQVc7SUFDckIsa0NBQW1CLENBQUE7SUFDbkIsZ0NBQWlCLENBQUE7QUFDbkIsQ0FBQyxFQUhXLFdBQVcsR0FBWCxtQkFBVyxLQUFYLG1CQUFXLFFBR3RCO0FBRUQsSUFBWSxTQUlYO0FBSkQsV0FBWSxTQUFTO0lBQ25CLHdDQUEyQixDQUFBO0lBQzNCLHdDQUEyQixDQUFBO0lBQzNCLDBCQUFhLENBQUE7QUFDZixDQUFDLEVBSlcsU0FBUyxHQUFULGlCQUFTLEtBQVQsaUJBQVMsUUFJcEI7QUFvRFksUUFBQSxtQkFBbUIsR0FBdUI7SUFDckQsT0FBTyxFQUFFLEtBQUs7SUFDZCxTQUFTLEVBQUUsS0FBSztJQUNoQixrQkFBa0IsRUFBRSwwQkFBa0IsQ0FBQyxPQUFPO0NBQy9DLENBQUMifQ==

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

@@ -0,0 +1,9 @@
+import CachedEntitlement from './cachedEntitlement';
+export interface CacheService {
+    clearCache(): void;
+    setCustomer(customerId: string, customerEntitlements: Map<string, CachedEntitlement>): void;
+    getCustomerEntitlements(customerId: string): Map<string, CachedEntitlement> | null;
+    setEntitlement(customerId: string, featureId: string, entitlement: CachedEntitlement): void;
+    validateFeature(featureId: string): boolean;
+    setFeatures(features: string[]): void;
+}

package/dist/services/cache/cacheService.js

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

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

@@ -0,0 +1,18 @@
+import { FeatureType, MeterType } from '../../models';
+export interface CalculatedEntitlement {
+    featureType: FeatureType;
+    usageLimit?: number | null;
+    featureUnits?: string;
+    featureUnitsPlural?: string;
+    hasUnlimitedUsage: boolean;
+    meterType: MeterType.Fluctuating | MeterType.Incremental | MeterType.None;
+}
+export interface FeatureUsage {
+    currentUsage: number;
+    nextResetDate: number;
+}
+export default class CachedEntitlement {
+    readonly calculatedEntitlement: CalculatedEntitlement;
+    readonly featureUsage: FeatureUsage;
+    constructor(calculatedEntitlement: CalculatedEntitlement, featureUsage: FeatureUsage);
+}

package/dist/services/cache/cachedEntitlement.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CachedEntitlement {
+    constructor(calculatedEntitlement, featureUsage) {
+        this.calculatedEntitlement = calculatedEntitlement;
+        this.featureUsage = featureUsage;
+    }
+}
+exports.default = CachedEntitlement;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkRW50aXRsZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvY2FjaGUvY2FjaGVkRW50aXRsZW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFnQkEsTUFBcUIsaUJBQWlCO0lBSXBDLFlBQVkscUJBQTRDLEVBQUUsWUFBMEI7UUFDbEYsSUFBSSxDQUFDLHFCQUFxQixHQUFHLHFCQUFxQixDQUFDO1FBQ25ELElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO0lBQ25DLENBQUM7Q0FDRjtBQVJELG9DQVFDIn0=

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

@@ -0,0 +1,13 @@
+import { CacheService } from './cacheService';
+import CachedEntitlement from './cachedEntitlement';
+export declare class InMemoryCacheService implements CacheService {
+    private readonly entitlements;
+    private featureIds;
+    constructor();
+    validateFeature(featureId: string): boolean;
+    clearCache: () => void;
+    setFeatures: (featureIds: string[]) => Set<string>;
+    setCustomer(customerId: string, customerEntitlements: Map<string, CachedEntitlement>): void;
+    setEntitlement(customerId: string, featureId: string, entitlement: CachedEntitlement): void;
+    getCustomerEntitlements(customerId: string): Map<string, CachedEntitlement> | null;
+}

package/dist/services/cache/inMemoryCacheService.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCacheService = void 0;
+class InMemoryCacheService {
+    constructor() {
+        this.clearCache = () => {
+            this.entitlements.clear();
+            this.featureIds.clear();
+        };
+        this.setFeatures = (featureIds) => (this.featureIds = new Set(featureIds));
+        this.entitlements = new Map();
+        this.featureIds = new Set();
+    }
+    validateFeature(featureId) {
+        return this.featureIds.has(featureId);
+    }
+    setCustomer(customerId, customerEntitlements) {
+        this.entitlements.set(customerId, customerEntitlements);
+    }
+    setEntitlement(customerId, featureId, entitlement) {
+        const customerEntitlements = this.entitlements.get(customerId);
+        if (!customerEntitlements) {
+            this.entitlements.set(customerId, new Map([[featureId, entitlement]]));
+            return;
+        }
+        customerEntitlements.set(featureId, entitlement);
+    }
+    getCustomerEntitlements(customerId) {
+        return this.entitlements.get(customerId) || null;
+    }
+}
+exports.InMemoryCacheService = InMemoryCacheService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5NZW1vcnlDYWNoZVNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvY2FjaGUvaW5NZW1vcnlDYWNoZVNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBTUEsTUFBYSxvQkFBb0I7SUFHL0I7UUFTQSxlQUFVLEdBQUcsR0FBRyxFQUFFO1lBQ2hCLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDMUIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMxQixDQUFDLENBQUM7UUFFRixnQkFBVyxHQUFHLENBQUMsVUFBb0IsRUFBRSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksR0FBRyxDQUFTLFVBQVUsQ0FBQyxDQUFDLENBQUM7UUFidEYsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLEdBQUcsRUFBMEMsQ0FBQztRQUN0RSxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7SUFDdEMsQ0FBQztJQUVELGVBQWUsQ0FBQyxTQUFpQjtRQUMvQixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFTRCxXQUFXLENBQUMsVUFBa0IsRUFBRSxvQkFBb0Q7UUFDbEYsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLG9CQUFvQixDQUFDLENBQUM7SUFDMUQsQ0FBQztJQUVELGNBQWMsQ0FBQyxVQUFrQixFQUFFLFNBQWlCLEVBQUUsV0FBOEI7UUFDbEYsTUFBTSxvQkFBb0IsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUUvRCxJQUFJLENBQUMsb0JBQW9CLEVBQUU7WUFDekIsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLElBQUksR0FBRyxDQUE0QixDQUFDLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ2xHLE9BQU87U0FDUjtRQUVELG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxTQUFTLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVELHVCQUF1QixDQUFDLFVBQWtCO1FBQ3hDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLElBQUksSUFBSSxDQUFDO0lBQ25ELENBQUM7Q0FDRjtBQXJDRCxvREFxQ0MifQ==

package/dist/services/entitlementDecisionService.d.ts

@@ -0,0 +1,9 @@
+import CachedEntitlement from './cache/cachedEntitlement';
+import { AccessDeniedReason } from '../api/generated/types';
+export declare class EntitlementDecisionService {
+    static decideEntitlementPolicy(customerExists: boolean, entitlement?: CachedEntitlement | null, requestUsage?: number): Decision;
+}
+export interface Decision {
+    readonly isGranted: boolean;
+    readonly accessDeniedReason?: AccessDeniedReason;
+}

package/dist/services/entitlementDecisionService.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementDecisionService = void 0;
+const types_1 = require("../api/generated/types");
+const models_1 = require("../models");
+// TODO: Extract to a common lib for other sdks
+class EntitlementDecisionService {
+    static decideEntitlementPolicy(customerExists, entitlement, requestUsage) {
+        var _a;
+        if (!customerExists) {
+            return { accessDeniedReason: types_1.AccessDeniedReason.CustomerNotFound, isGranted: false };
+        }
+        if (!entitlement) {
+            return { isGranted: false, accessDeniedReason: types_1.AccessDeniedReason.NoFeatureEntitlementInSubscription };
+        }
+        const featureType = entitlement.calculatedEntitlement.featureType;
+        const meterType = entitlement.calculatedEntitlement.meterType;
+        switch (featureType) {
+            case models_1.FeatureType.Boolean:
+                return { isGranted: true };
+            case models_1.FeatureType.Number: {
+                if (entitlement.calculatedEntitlement.meterType === models_1.MeterType.None) {
+                    return { isGranted: true };
+                }
+                if (entitlement.calculatedEntitlement.hasUnlimitedUsage) {
+                    return { isGranted: true };
+                }
+                let currentUsage = entitlement.featureUsage.currentUsage;
+                if (meterType === models_1.MeterType.Incremental && entitlement.featureUsage.nextResetDate < new Date().getTime()) {
+                    currentUsage = 0;
+                }
+                if (currentUsage + (requestUsage || 0) <= (((_a = entitlement.calculatedEntitlement) === null || _a === void 0 ? void 0 : _a.usageLimit) || 0)) {
+                    return { isGranted: true };
+                }
+                else {
+                    return { isGranted: false, accessDeniedReason: types_1.AccessDeniedReason.RequestedUsageExceedingLimit };
+                }
+            }
+        }
+    }
+}
+exports.EntitlementDecisionService = EntitlementDecisionService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXRsZW1lbnREZWNpc2lvblNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvZW50aXRsZW1lbnREZWNpc2lvblNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0Esa0RBQTREO0FBQzVELHNDQUFtRDtBQUVuRCwrQ0FBK0M7QUFDL0MsTUFBYSwwQkFBMEI7SUFDOUIsTUFBTSxDQUFDLHVCQUF1QixDQUNuQyxjQUF1QixFQUN2QixXQUFzQyxFQUN0QyxZQUFxQjs7UUFFckIsSUFBSSxDQUFDLGNBQWMsRUFBRTtZQUNuQixPQUFPLEVBQUUsa0JBQWtCLEVBQUUsMEJBQWtCLENBQUMsZ0JBQWdCLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxDQUFDO1NBQ3RGO1FBQ0QsSUFBSSxDQUFDLFdBQVcsRUFBRTtZQUNoQixPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxrQkFBa0IsRUFBRSwwQkFBa0IsQ0FBQyxrQ0FBa0MsRUFBRSxDQUFDO1NBQ3hHO1FBRUQsTUFBTSxXQUFXLEdBQUcsV0FBVyxDQUFDLHFCQUFxQixDQUFDLFdBQVcsQ0FBQztRQUNsRSxNQUFNLFNBQVMsR0FBRyxXQUFXLENBQUMscUJBQXFCLENBQUMsU0FBUyxDQUFDO1FBRTlELFFBQVEsV0FBVyxFQUFFO1lBQ25CLEtBQUssb0JBQVcsQ0FBQyxPQUFPO2dCQUN0QixPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDO1lBQzdCLEtBQUssb0JBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztnQkFDdkIsSUFBSSxXQUFXLENBQUMscUJBQXFCLENBQUMsU0FBUyxLQUFLLGtCQUFTLENBQUMsSUFBSSxFQUFFO29CQUNsRSxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDO2lCQUM1QjtnQkFDRCxJQUFJLFdBQVcsQ0FBQyxxQkFBcUIsQ0FBQyxpQkFBaUIsRUFBRTtvQkFDdkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQztpQkFDNUI7Z0JBRUQsSUFBSSxZQUFZLEdBQUcsV0FBVyxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUM7Z0JBQ3pELElBQUksU0FBUyxLQUFLLGtCQUFTLENBQUMsV0FBVyxJQUFJLFdBQVcsQ0FBQyxZQUFZLENBQUMsYUFBYSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQUU7b0JBQ3hHLFlBQVksR0FBRyxDQUFDLENBQUM7aUJBQ2xCO2dCQUNELElBQUksWUFBWSxHQUFHLENBQUMsWUFBWSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQSxNQUFBLFdBQVcsQ0FBQyxxQkFBcUIsMENBQUUsVUFBVSxLQUFJLENBQUMsQ0FBQyxFQUFFO29CQUM5RixPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDO2lCQUM1QjtxQkFBTTtvQkFDTCxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxrQkFBa0IsRUFBRSwwQkFBa0IsQ0FBQyw0QkFBNEIsRUFBRSxDQUFDO2lCQUNsRzthQUNGO1NBQ0Y7SUFDSCxDQUFDO0NBQ0Y7QUF2Q0QsZ0VBdUNDIn0=

package/dist/services/entitlementsService.d.ts

@@ -0,0 +1,22 @@
+import { CacheService } from './cache/cacheService';
+import { ApolloClient, FetchResult, NormalizedCacheObject } from '@apollo/client/core';
+import { CreateUsageMeasurement, Entitlement, InvalidEntitlement } from '../models';
+import { Decision } from './entitlementDecisionService';
+import CachedEntitlement from './cache/cachedEntitlement';
+import { LoggerService } from './loggerService';
+export declare class EntitlementsService {
+    private readonly cacheService;
+    private readonly loggerService;
+    private readonly entitlementsApi;
+    private readonly modelMapper;
+    constructor(cacheService: CacheService, client: ApolloClient<NormalizedCacheObject>, loggerService: LoggerService);
+    private onEntitlementsUpdated;
+    getEntitlement<T extends Entitlement>(featureRefId: string, customerRefId: string, requestedUsage?: number): Promise<T | InvalidEntitlement>;
+    private onUsageUpdated;
+    private tryGetCacheCustomerAndEntitlement;
+    createUsageMeasurement(input: CreateUsageMeasurement): Promise<FetchResult<import("../api/generated/types").CreateUsageMeasurementMutation, Record<string, any>, Record<string, any>>>;
+}
+export declare type GetEntitlementResult = {
+    entitlement: CachedEntitlement | null;
+    decision: Decision;
+};