@splitsoftware/splitio-commons 1.2.1-rc.9 → 1.3.1-rc.1

package/types/sdkClient/sdkClient.d.ts

@@ -1,6 +1,6 @@
 import { SplitIO } from '../types';
-import { ISdkClientFactoryParams } from './types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export declare function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClientMethod.d.ts

@@ -1,6 +1,6 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export declare function sdkClientMethodFactory(params: ISdkClientFactoryParams): () => SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClientMethodCS.d.ts

@@ -1,7 +1,7 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for the client-side API variant where TT is ignored and thus
  * clients don't have a binded TT for the track method.
  */
-export declare function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?: SplitIO.SplitKey) => SplitIO.ICsClient;
+export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient;

package/types/sdkClient/sdkClientMethodCSWithTT.d.ts

@@ -1,8 +1,8 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
  * where clients can have a binded TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
-export declare function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient;
+export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient;

package/types/sdkFactory/types.d.ts

@@ -2,12 +2,21 @@ import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { ISdkClientFactoryParams } from '../sdkClient/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
+import { IImpressionsTracker, IEventTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
+export interface ISdkFactoryContext {
+    storage: IStorageSync | IStorageAsync;
+    sdkReadinessManager: ISdkReadinessManager;
+    settings: ISettings;
+    impressionsTracker: IImpressionsTracker;
+    eventTracker: IEventTracker;
+    signalListener?: ISignalListener;
+    syncManager?: ISyncManager;
+}
 /**
  * Environment related dependencies.
  * These getters are called a fixed number of times per factory instantiation.
@@ -28,7 +37,7 @@ export interface ISdkFactoryParams {
     splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi;
     syncManagerFactory?: (params: ISyncManagerFactoryParams) => ISyncManager;
     sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
-    sdkClientMethodFactory: (params: ISdkClientFactoryParams) => ({
+    sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
@@ -38,5 +47,5 @@ export interface ISdkFactoryParams {
     serviceApi: ISplitApi | undefined) => ISignalListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
     impressionsObserverFactory?: () => IImpressionObserver;
-    extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object;
+    extraProps?: (params: ISdkFactoryContext) => object;
 }

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
 import { TelemetryCacheSync } from '../types';
 export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     private timeUntilReady?;
@@ -17,16 +17,14 @@ export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     getEventStats(type: EventDataType): number;
     recordEventStats(type: EventDataType, count: number): void;
     private lastSync;
-    getLastSynchronization(): Record<OperationType, number | undefined>;
+    getLastSynchronization(): LastSync;
     recordSuccessfulSync(resource: OperationType, timeMs: number): void;
     private httpErrors;
-    popHttpErrors(): Record<OperationType, {
-        [statusCode: string]: number;
-    }>;
-    recordSyncError(resource: OperationType, status: number): void;
+    popHttpErrors(): HttpErrors;
+    recordHttpError(resource: OperationType, status: number): void;
     private httpLatencies;
-    popHttpLatencies(): Record<OperationType, number[]>;
-    recordSyncLatency(resource: OperationType, latencyMs: number): void;
+    popHttpLatencies(): HttpLatencies;
+    recordHttpLatency(resource: OperationType, latencyMs: number): void;
     private authRejections;
     popAuthRejections(): number;
     recordAuthRejections(): void;
@@ -43,9 +41,9 @@ export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     getSessionLength(): number | undefined;
     recordSessionLength(ms: number): void;
     private exceptions;
-    popExceptions(): Record<Method, number>;
+    popExceptions(): MethodExceptions;
     recordException(method: Method): void;
     private latencies;
-    popLatencies(): Record<Method, number[]>;
+    popLatencies(): MethodLatencies;
     recordLatency(method: Method, latencyMs: number): void;
 }

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -0,0 +1,19 @@
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { TelemetryCacheAsync } from '../types';
+import { Redis } from 'ioredis';
+export declare class TelemetryCacheInRedis implements TelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly redis;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param redis  Redis client.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    recordLatency(method: Method, latencyMs: number): Promise<number | void>;
+    recordException(method: Method): Promise<number | void>;
+}

package/types/storages/pluggable/TelemetryCachePluggable.d.ts

@@ -1,2 +1,18 @@
-export declare class TelemetryCachePluggable {
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { IPluggableStorageWrapper, TelemetryCacheAsync } from '../types';
+export declare class TelemetryCachePluggable implements TelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly wrapper;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param wrapper  Adapted wrapper storage.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
+    recordLatency(method: Method, latencyMs: number): Promise<number | void>;
+    recordException(method: Method): Promise<number | void>;
 }

package/types/sync/submitters/telemetrySyncTask.d.ts

@@ -1,17 +1,27 @@
 import { ISyncTask, ITimeTracker } from '../types';
-import { IPostMetricsUsage } from '../../services/types';
+import { ISplitApi } from '../../services/types';
 import { IStorageSync, TelemetryCacheSync } from '../../storages/types';
-import { TelemetryStatsPayload } from './types';
-import { ILogger } from '../../logger/types';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
+import { IReadinessManager } from '../../readiness/types';
+import { ISettings } from '../../types';
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export declare function telemetryCacheAdapter(telemetryCache: TelemetryCacheSync, storage: IStorageSync): {
+export declare function telemetryCacheStatsAdapter({ splits, segments, telemetry }: IStorageSync & {
+    telemetry: TelemetryCacheSync;
+}): {
     isEmpty(): boolean;
     clear(): void;
-    state(): TelemetryStatsPayload;
+    state(): TelemetryUsageStatsPayload;
+};
+export declare function telemetryCacheConfigAdapter(settings: ISettings, telemetryCache: TelemetryCacheSync): {
+    isEmpty(): boolean;
+    clear(): void;
+    state(): TelemetryConfigStatsPayload;
 };
 /**
  * Sync task that periodically posts impressions data
  */
-export declare function telemetrySyncTaskFactory(log: ILogger, postMetricsUsage: IPostMetricsUsage, telemetryCache: TelemetryCacheSync, telemetryRefreshRate: number, latencyTracker: ITimeTracker, storage: IStorageSync): ISyncTask;
+export declare function telemetrySyncTaskFactory(settings: ISettings, { postMetricsUsage, postMetricsConfig }: ISplitApi, storage: IStorageSync & {
+    telemetry: TelemetryCacheSync;
+}, telemetryRefreshRate: number, readiness: IReadinessManager, latencyTracker?: ITimeTracker): ISyncTask;

package/types/trackers/telemetryTracker.d.ts

@@ -0,0 +1,4 @@
+import { TelemetryCacheAsync, TelemetryCacheSync } from '../storages/types';
+import { ISettings } from '../types';
+import { ITelemetryTracker } from './types';
+export declare function telemetryTrackerFactory(settings: ISettings, telemetryCache?: TelemetryCacheAsync | TelemetryCacheSync, now?: () => number): ITelemetryTracker;

package/types/types.d.ts

@@ -526,8 +526,8 @@ export declare namespace SplitIO {
     type ImpressionData = {
         impression: ImpressionDTO;
         attributes?: SplitIO.Attributes;
-        ip: string;
-        hostname: string;
+        ip: string | false;
+        hostname: string | false;
         sdkLanguageVersion: string;
     };
     /**

package/types/utils/lang/index.d.ts

@@ -55,7 +55,8 @@ export declare function isIntegerNumber(val: any): boolean;
  */
 export declare function isNaNNumber(val: any): boolean;
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
 export declare function isObject(obj: any): boolean;
 /**

package/types/utils/settingsValidation/types.d.ts

@@ -13,8 +13,10 @@ export interface ISettingsValidationParams {
     } & {
         startup: ISettings['startup'];
     };
-    /** If true, validates core.key and core.trafficType */
-    isClientSide?: boolean;
+    /** If true, validates core.key */
+    acceptKey?: boolean;
+    /** If true, validates core.trafficType */
+    acceptTT?: boolean;
     /** Define runtime values (`settings.runtime`) */
     runtime: (settings: ISettings) => ISettings['runtime'];
     /** Storage validator (`settings.storage`) */

package/cjs/sdkClient/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/sdkFactory/userConsentProps.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.userConsentProps = void 0;
-var constants_1 = require("../logger/constants");
-var constants_2 = require("../utils/constants");
-var lang_1 = require("../utils/lang");
-// Extend client-side factory instances with user consent getter/setter
-function userConsentProps(settings, syncManager) {
-    var log = settings.log;
-    return {
-        setUserConsent: function (consent) {
-            var _a, _b;
-            // validate input param
-            if (!(0, lang_1.isBoolean)(consent)) {
-                log.warn(constants_1.ERROR_NOT_BOOLEAN, ['setUserConsent']);
-                return false;
-            }
-            var newConsentStatus = consent ? constants_2.CONSENT_GRANTED : constants_2.CONSENT_DECLINED;
-            if (settings.userConsent !== newConsentStatus) { // @ts-ignore, modify readonly prop
-                settings.userConsent = newConsentStatus;
-                if (consent)
-                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start(); // resumes submitters if transitioning to GRANTED
-                else
-                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.stop(); // pauses submitters if transitioning to DECLINED
-                log.info(constants_1.USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]);
-            }
-            else {
-                log.info(constants_1.USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
-            }
-            return true;
-        },
-        getUserConsent: function () {
-            return settings.userConsent;
-        }
-    };
-}
-exports.userConsentProps = userConsentProps;

package/esm/sdkClient/types.js

@@ -1 +0,0 @@
-export {};

package/esm/sdkFactory/userConsentProps.js

@@ -1,33 +0,0 @@
-import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED } from '../logger/constants';
-import { CONSENT_GRANTED, CONSENT_DECLINED } from '../utils/constants';
-import { isBoolean } from '../utils/lang';
-// Extend client-side factory instances with user consent getter/setter
-export function userConsentProps(settings, syncManager) {
-    var log = settings.log;
-    return {
-        setUserConsent: function (consent) {
-            var _a, _b;
-            // validate input param
-            if (!isBoolean(consent)) {
-                log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
-                return false;
-            }
-            var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
-            if (settings.userConsent !== newConsentStatus) { // @ts-ignore, modify readonly prop
-                settings.userConsent = newConsentStatus;
-                if (consent)
-                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start(); // resumes submitters if transitioning to GRANTED
-                else
-                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.stop(); // pauses submitters if transitioning to DECLINED
-                log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]);
-            }
-            else {
-                log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
-            }
-            return true;
-        },
-        getUserConsent: function () {
-            return settings.userConsent;
-        }
-    };
-}

package/src/sdkClient/types.ts

@@ -1,21 +0,0 @@
-import { ISignalListener } from '../listeners/types';
-import { ISdkReadinessManager } from '../readiness/types';
-import { IStorageAsync, IStorageSync } from '../storages/types';
-import { ISyncManager } from '../sync/types';
-import { IEventTracker, IImpressionsTracker } from '../trackers/types';
-import { ISettings } from '../types';
-
-export interface IClientFactoryParams {
-  storage: IStorageSync | IStorageAsync,
-  sdkReadinessManager: ISdkReadinessManager,
-  settings: ISettings
-  impressionsTracker: IImpressionsTracker,
-  eventTracker: IEventTracker,
-  // @TODO add time tracker and metricCollectors (a.k.a metricTracker)?
-}
-
-export interface ISdkClientFactoryParams extends IClientFactoryParams {
-  signalListener?: ISignalListener
-  syncManager?: ISyncManager,
-  sharedClient?: boolean
-}

package/src/sdkFactory/userConsentProps.ts

@@ -1,40 +0,0 @@
-import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED } from '../logger/constants';
-import { ISyncManager } from '../sync/types';
-import { ISettings } from '../types';
-import { CONSENT_GRANTED, CONSENT_DECLINED } from '../utils/constants';
-import { isBoolean } from '../utils/lang';
-
-// Extend client-side factory instances with user consent getter/setter
-export function userConsentProps(settings: ISettings, syncManager?: ISyncManager) {
-
-  const log = settings.log;
-
-  return {
-    setUserConsent(consent: unknown) {
-      // validate input param
-      if (!isBoolean(consent)) {
-        log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
-        return false;
-      }
-
-      const newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
-
-      if (settings.userConsent !== newConsentStatus) { // @ts-ignore, modify readonly prop
-        settings.userConsent = newConsentStatus;
-
-        if (consent) syncManager?.submitter?.start(); // resumes submitters if transitioning to GRANTED
-        else syncManager?.submitter?.stop(); // pauses submitters if transitioning to DECLINED
-
-        log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]);
-      } else {
-        log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
-      }
-
-      return true;
-    },
-
-    getUserConsent() {
-      return settings.userConsent;
-    }
-  };
-}