@stigg/js-client-sdk 0.22.2 → 0.25.0

package/dist/models.d.ts

@@ -1,96 +1,92 @@
-import { AccessDeniedReason, BillingModel, BillingPeriod, EntitlementResetPeriod, MonthlyAccordingTo, PromotionalEntitlementStatus, SubscriptionStatus, TrialPeriodUnits, WeeklyAccordingTo } from './api/generated/types';
-export { BillingPeriod, BillingModel, ErrorCode, AccessDeniedReason, EntitlementResetPeriod, TrialPeriodUnits, } from './api/generated/types';
+import { BillingModel, BillingPeriod, Currency, PromotionalEntitlementStatus, SubscriptionStatus, TrialPeriodUnits } from './api/generated/types';
+export { SubscriptionStatus, PromotionalEntitlementStatus, Currency, BillingPeriod, BillingModel, TrialPeriodUnits, } from './api/generated/types';
+export declare enum AccessDeniedReason {
+    InvalidFeatureType = "InvalidFeatureType",
+    CustomerNotFound = "CustomerNotFound",
+    FeatureNotFound = "FeatureNotFound",
+    NoActiveSubscriptions = "NoActiveSubscriptions",
+    CustomerNotEntitledForFeature = "CustomerNotEntitledForFeature",
+    RequestedUsageExceedsLimit = "RequestedUsageExceedsLimit",
+    Unknown = "Unknown"
+}
 export declare enum FeatureType {
-    Boolean = "BOOLEAN",
-    Number = "NUMBER"
+    Boolean = "Boolean",
+    Numeric = "Numeric"
 }
 export declare enum MeterType {
     Fluctuating = "Fluctuating",
     Incremental = "Incremental",
     None = "None"
 }
-export declare type BaseEntitlement = {
-    isValid: boolean;
-    isGranted: boolean;
-    featureType?: FeatureType;
-    featureDisplayName?: string;
-    featureDescription?: string | null;
-    accessDeniedReason?: AccessDeniedReason | null;
-    featureId?: string | null;
-};
-export interface FallbackEntitlement extends BaseEntitlement {
-    isValid: false;
-}
-export interface InvalidEntitlement extends BaseEntitlement {
-    isValid: false;
-    isGranted: false;
-    accessDeniedReason: AccessDeniedReason.FeatureNotFound | AccessDeniedReason.CustomerNotFound | AccessDeniedReason.Unknown;
+export declare enum EntitlementResetPeriod {
+    Daily = "Daily",
+    Hourly = "Hourly",
+    Monthly = "Monthly",
+    Weekly = "Weekly"
 }
-export interface ValidEntitlement extends BaseEntitlement {
-    isValid: true;
-}
-export interface BooleanEntitlement extends ValidEntitlement {
-    featureType: FeatureType.Boolean;
+export declare type EntitlementFeature = {
+    id: string;
+    featureType: FeatureType;
+    displayName: string;
+    description?: string;
+    units?: string;
+    unitsPlural?: string;
+    meterType?: MeterType.Fluctuating | MeterType.Incremental | MeterType.None;
+    isMetered?: boolean;
+};
+export declare type BaseEntitlement = {
+    hasAccess: boolean;
+    isFallback: boolean;
+    accessDeniedReason?: AccessDeniedReason;
+    feature?: EntitlementFeature;
+};
+export interface BooleanEntitlement extends BaseEntitlement {
 }
-export interface NumberEntitlement extends ValidEntitlement {
-    featureType: FeatureType.Number;
-    usageLimit: number;
-    featureUnits?: string;
-    featureUnitsPlural?: string;
-    hasUnlimitedUsage: boolean;
+export interface NumericEntitlement extends BaseEntitlement {
+    value?: number;
+    isUnlimited: boolean;
 }
-export interface MeteredEntitlement extends NumberEntitlement {
-    featureType: FeatureType.Number;
-    meterType: MeterType.Fluctuating | MeterType.Incremental | MeterType.None;
+export declare type ResetSettings = {
+    nextResetDate: Date;
+    resetPeriod: EntitlementResetPeriod;
+};
+export interface MeteredEntitlement extends BaseEntitlement {
+    usageLimit?: number;
+    isUnlimited: boolean;
     currentUsage: number;
-    requestedUsage: number | null;
-    resetPeriod?: EntitlementResetPeriod | null;
-    nextResetDate?: any | null;
-    resetPeriodConfiguration?: {
-        __typename: 'MonthlyResetPeriodConfig';
-        monthlyAccordingTo?: MonthlyAccordingTo | null | undefined;
-    } | {
-        __typename: 'WeeklyResetPeriodConfig';
-        weeklyAccordingTo?: WeeklyAccordingTo | null | undefined;
-    } | null;
+    requestedUsage: number;
+    resetSettings?: ResetSettings;
 }
-export declare type Entitlement = FallbackEntitlement | InvalidEntitlement | BooleanEntitlement | NumberEntitlement | MeteredEntitlement;
-export declare const INVALID_ENTITLEMENT: InvalidEntitlement;
+export declare type Entitlement = BooleanEntitlement | NumericEntitlement | MeteredEntitlement;
+/** @internal */
+export declare const BOOLEAN_DEFAULT_FALLBACK_ENTITLEMENT: BooleanEntitlement;
+/** @internal */
+export declare const NUMERIC_DEFAULT_FALLBACK_ENTITLEMENT: NumericEntitlement;
+/** @internal */
+export declare const METERED_DEFAULT_FALLBACK_ENTITLEMENT: MeteredEntitlement;
 export declare type PackageEntitlement = {
     usageLimit: number;
-    featureType: FeatureType;
-    featureMeterType?: MeterType | null;
-    featureUnits?: string | null;
-    featureUnitsPlural?: string | null;
-    featureDisplayName: string;
-    featureDescription?: string | null;
-    featureId: string;
+    feature: EntitlementFeature;
     hasUnlimitedUsage?: boolean | null;
     resetPeriod?: EntitlementResetPeriod | null;
 };
 export declare type PromotionalEntitlement = {
     usageLimit: number;
-    featureType: FeatureType;
-    featureMeterType?: MeterType | null;
-    featureUnits?: string | null;
-    featureUnitsPlural?: string | null;
-    featureDisplayName: string;
-    featureDescription?: string | null;
-    featureId: string;
+    feature: EntitlementFeature;
     hasUnlimitedUsage?: boolean | null;
-    resetPeriod?: EntitlementResetPeriod | null;
     status: PromotionalEntitlementStatus;
-    endDate?: Date;
+    expiresAt?: Date;
+    hasExpirationDate: boolean;
     isVisible: boolean;
 };
 export declare type Price = {
-    billingModel: BillingModel;
+    pricingModel: BillingModel;
     billingPeriod: BillingPeriod;
     amount: number;
-    currency: string;
+    currency: Currency;
     feature?: {
-        featureUnits?: string | null | undefined;
-        featureUnitsPlural?: string | null | undefined;
+        units?: string | null | undefined;
+        unitsPlural?: string | null | undefined;
         displayName: string;
     } | null;
 };
@@ -106,7 +102,7 @@ export declare type Plan = {
     basePlan?: BasePlan;
     entitlements: PackageEntitlement[];
     inheritedEntitlements: PackageEntitlement[];
-    prices: Price[];
+    pricePoints: Price[];
     defaultTrialConfig?: DefaultTrialConfig | null;
     compatibleAddons: Addon[];
     product: Product;
@@ -119,15 +115,46 @@ export declare type DefaultTrialConfig = {
     duration: number;
     units: TrialPeriodUnits;
 };
-export declare type EntitlementOptions = {
-    requestedUsage?: number;
-    shouldTrack?: boolean;
-    fallbackGrantedValue?: boolean;
+export declare type GetBooleanEntitlement = {
+    featureId: string;
+    options?: BooleanEntitlementOptions;
 };
-export declare type FetchEntitlement = {
-    customerId: string;
+export declare type GetNumericEntitlement = {
     featureId: string;
-    options?: EntitlementOptions;
+    options?: NumericEntitlementOptions;
+};
+export declare type GetMeteredEntitlement = {
+    featureId: string;
+    options?: MeteredEntitlementOptions;
+};
+export declare type GetPaywall = {
+    productId?: string;
+};
+export declare type BooleanEntitlementFallback = {
+    hasAccess: boolean;
+};
+export declare type BooleanEntitlementOptions = {
+    shouldTrack?: boolean;
+    fallback?: BooleanEntitlementFallback;
+};
+export declare type NumericEntitlementFallback = {
+    hasAccess: boolean;
+    value?: number;
+    isUnlimited?: boolean;
+};
+export declare type NumericEntitlementOptions = {
+    shouldTrack?: boolean;
+    fallback?: NumericEntitlementFallback;
+};
+export declare type MeteredEntitlementFallback = {
+    hasAccess: boolean;
+    usageLimit?: number;
+    isUnlimited?: boolean;
+};
+export declare type MeteredEntitlementOptions = {
+    requestedUsage?: number;
+    shouldTrack?: boolean;
+    fallback?: MeteredEntitlementFallback;
 };
 export declare type Addon = {
     id: string;
@@ -162,7 +189,8 @@ export declare type Customer = {
     getActivePromotionalEntitlements(): PromotionalEntitlement[];
     getActiveTrials(): Subscription[];
 };
-declare type CustomerState = Omit<Customer, 'getActiveSubscriptions' | 'getActivePromotionalEntitlements' | 'getActiveTrials'>;
+export declare type CustomerState = Omit<Customer, 'getActiveSubscriptions' | 'getActivePromotionalEntitlements' | 'getActiveTrials'>;
+/** @hidden */
 export declare class CustomerModel implements Customer {
     id: string;
     createdAt: Date;

package/dist/services/cachedEntitlement.d.ts

@@ -1,15 +1,9 @@
-import { EntitlementResetPeriod, FeatureType, MeterType } from '../models';
+import { EntitlementFeature, EntitlementResetPeriod } from '../models';
 import { ResetPeriodConfigurationFragment } from '../api/generated/types';
 export interface CalculatedEntitlement {
-    featureId: string;
-    featureType: FeatureType;
     usageLimit?: number | null;
-    featureUnits?: string;
-    featureUnitsPlural?: string;
-    featureDisplayName?: string;
-    featureDescription?: string | null;
     hasUnlimitedUsage: boolean;
-    meterType: MeterType.Fluctuating | MeterType.Incremental | MeterType.None;
+    feature?: EntitlementFeature;
 }
 export interface EntitlementUsage {
     currentUsage: number;

package/dist/services/entitlementDecisionService.d.ts

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

package/dist/services/entitlementsService.d.ts

@@ -1,9 +1,9 @@
-import { CacheService } from './cacheService';
 import { ApolloClient, NormalizedCacheObject } from '@apollo/client/core';
-import { Entitlement, InvalidEntitlement } from '../models';
-import { Decision } from './entitlementDecisionService';
-import CachedEntitlement from './cachedEntitlement';
 import { EntitlementFragment } from '../api/generated/types';
+import { BooleanEntitlement, MeteredEntitlement, MeteredEntitlementOptions, NumericEntitlement } from '../models';
+import CachedEntitlement from './cachedEntitlement';
+import { CacheService } from './cacheService';
+import { Decision } from './entitlementDecisionService';
 export declare class EntitlementsService {
     private readonly customerId;
     private readonly cacheService;
@@ -14,11 +14,13 @@ export declare class EntitlementsService {
     constructor(customerId: string, cacheService: CacheService, client: ApolloClient<NormalizedCacheObject>);
     startPolling(interval: number): void;
     refresh(): Promise<void>;
-    getEntitlement<T extends Entitlement>(featureRefId: string, requestedUsage?: number): T | InvalidEntitlement;
+    getBooleanEntitlement(featureId: string): BooleanEntitlement;
+    getNumericEntitlement(featureId: string): NumericEntitlement;
+    getMeteredEntitlement(featureId: string, options?: MeteredEntitlementOptions): MeteredEntitlement;
     loadEntitlements(): Promise<void>;
-    private doLoadEntitlements;
-    protected handleFetchedEntitlements(entitlements: Array<EntitlementFragment>): void;
-    getEntitlements(): Promise<Entitlement[]>;
+    private loadEntitlementsFromRemote;
+    protected storeFetchedEntitlementsInCache(entitlements: EntitlementFragment[]): void;
+    getEntitlements(): Promise<BooleanEntitlement[]>;
     stopPolling(): void;
 }
 export declare type GetEntitlementResult = {

package/dist/services/loggerService.d.ts

@@ -0,0 +1,21 @@
+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;
+}
+export declare enum LogLevel {
+    ALL = "ALL",
+    NONE = "NONE",
+    LOG = "LOG",
+    ERROR = "ERROR"
+}
+export declare class LoggerService implements Logger {
+    private readonly logger;
+    private readonly logLevel;
+    constructor(logger: Logger, logLevel: LogLevel);
+    error(message: string, error?: Record<string, string>): void;
+    log(message: string, object?: Record<string, string>): void;
+}

package/dist/utils/ModelMapper.d.ts

@@ -1,18 +1,20 @@
-import { CustomerFragment, EntitlementFragment, GetPlansQuery, SlimEntitlementFragment } from '../api/generated/types';
-import { Customer, Entitlement, Plan } from '../models';
+import { CustomerFragment, EntitlementFragment, GetPlansQuery, FeatureType as ApiFeatureType, EntitlementResetPeriod as ApiEntitlementResetPeriod } from '../api/generated/types';
+import { BooleanEntitlement, Customer, FeatureType, MeteredEntitlement, NumericEntitlement, Plan, EntitlementResetPeriod } from '../models';
 import CachedEntitlement from '../services/cachedEntitlement';
 import { Decision } from '../services/entitlementDecisionService';
 export declare class ModelMapper {
-    mapEntitlementByDecision: (decision: Decision, featureId: string, entitlement: CachedEntitlement, requestedUsage?: number | undefined) => Entitlement;
-    mapSlimEntitlement(entitlement: SlimEntitlementFragment): Entitlement;
-    mapFullEntitlementByDecision(entitlement: CachedEntitlement, decision: Decision, customerId: string, requestedUsage?: number): Entitlement;
-    mapFullEntitlement(fullEntitlement: EntitlementFragment): Entitlement;
+    mapBooleanEntitlement(entitlement: CachedEntitlement, decision: Decision): BooleanEntitlement;
+    mapNumericEntitlement(entitlement: CachedEntitlement, decision: Decision): NumericEntitlement;
+    mapMeteredEntitlement(entitlement: CachedEntitlement, decision: Decision, requestedUsage?: number): MeteredEntitlement;
+    mapEntitlement(entitlement: CachedEntitlement, decision: Decision, requestedUsage?: number): BooleanEntitlement;
+    mapFeatureType(featureType: ApiFeatureType): FeatureType;
+    mapEntitlementResetPeriod(resetPeriod: ApiEntitlementResetPeriod): EntitlementResetPeriod;
     mapCachedEntitlement(entitlement: EntitlementFragment, currentUsage?: number, nextResetDate?: number | null): CachedEntitlement;
     mapCachedEntitlements(updatedEntitlements: EntitlementFragment[]): Map<string, CachedEntitlement>;
     mapPlans(resultData: GetPlansQuery): Plan[];
+    mapCustomer(customer: CustomerFragment): Customer;
     private mapPrice;
     private mapPlan;
-    mapCustomer(customer: CustomerFragment): Customer;
     private mapPackageEntitlement;
     private mapPromotionalEntitlement;
     private mapSubscription;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigg/js-client-sdk",
-  "version": "0.22.2",
+  "version": "0.25.0",
   "description": "Stigg client-side SDK for Browser",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -19,16 +19,17 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
-    "prepare": "husky install"
+    "prepare": "husky install",
+    "docs": "typedoc"
   },
   "files": [
     "dist/**/*"
   ],
   "dependencies": {
     "@apollo/client": "^3.4.17",
+    "cross-fetch": "^3.1.4",
     "graphql": "^16.0.1",
     "husky": "^7.0.4",
-    "cross-fetch": "^3.1.4",
     "lint-staged": "^12.0.2",
     "lodash": "^4.17.21"
   },
@@ -49,12 +50,14 @@
     "eslint-plugin-prettier": "^4.0.0",
     "jest": "^27.3.1",
     "jest-fetch-mock": "^3.0.3",
+    "msw": "^0.35.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.4.1",
     "ts-jest": "^27.0.7",
     "ts-loader": "^9.2.6",
+    "typedoc": "^0.22.13",
+    "typedoc-plugin-rename-defaults": "^0.4.0",
     "typescript": "^4.5.3",
-    "msw": "^0.35.0",
     "webpack": "^5.64.1",
     "webpack-cli": "^4.9.1",
     "webpack-dev-server": "^4.5.0"