@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/sync/polling/syncTasks/splitsSyncTask.ts

@@ -1,35 +0,0 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { syncTaskFactory } from '../../syncTask';
-import { ISplitsSyncTask } from '../types';
-import { splitChangesFetcherFactory } from '../fetchers/splitChangesFetcher';
-import { IFetchSplitChanges } from '../../../services/types';
-import { ISettings } from '../../../types';
-import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
-
-/**
- * Creates a sync task that periodically executes a `splitChangesUpdater` task
- */
-export function splitsSyncTaskFactory(
-  fetchSplitChanges: IFetchSplitChanges,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings,
-  isClientSide?: boolean
-): ISplitsSyncTask {
-  return syncTaskFactory(
-    settings.log,
-    splitChangesUpdaterFactory(
-      settings.log,
-      splitChangesFetcherFactory(fetchSplitChanges, settings, storage),
-      storage,
-      settings.sync.__splitFiltersValidation,
-      readiness.splits,
-      settings.startup.requestTimeoutBeforeReady,
-      settings.startup.retriesOnFailureBeforeReady,
-      isClientSide
-    ),
-    settings.scheduler.featuresRefreshRate,
-    'splitChangesUpdater',
-  );
-}

package/src/sync/polling/types.ts

@@ -1,33 +0,0 @@
-import { IRBSegment, ISplit } from '../../dtos/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IStorageSync } from '../../storages/types';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
-import { ITask, ISyncTask } from '../types';
-
-export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit | IRBSegment, changeNumber: number }], boolean> { }
-
-export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
-
-export type MySegmentsData = {
-  type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE
-  cn: number
-  added: string[]
-  removed: string[]
-}
-
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> { }
-
-export interface IPollingManager extends ITask {
-  syncAll(): Promise<any>
-  splitsSyncTask: ISplitsSyncTask
-  segmentsSyncTask: ISyncTask
-}
-
-/**
- * PollingManager for client-side with support for multiple clients
- */
-export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
-  remove(matchingKey: string): void;
-  get(matchingKey: string): IMySegmentsSyncTask | undefined
-}

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -1,102 +0,0 @@
-import { IMySegmentsFetcher } from '../fetchers/types';
-import { IStorageSync } from '../../../storages/types';
-import { ISegmentsEventEmitter } from '../../../readiness/types';
-import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
-import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
-import { MySegmentsData } from '../types';
-import { IMembershipsResponse } from '../../../dtos/types';
-import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
-import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
-
-type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
-
-/**
- * factory of MySegments updater, a task that:
- *  - fetches mySegments using `mySegmentsFetcher`
- *  - updates `mySegmentsCache`
- *  - uses `segmentsEventEmitter` to emit events related to segments data updates
- */
-export function mySegmentsUpdaterFactory(
-  log: ILogger,
-  mySegmentsFetcher: IMySegmentsFetcher,
-  storage: IStorageSync,
-  segmentsEventEmitter: ISegmentsEventEmitter,
-  requestTimeoutBeforeReady: number,
-  retriesOnFailureBeforeReady: number,
-  matchingKey: string
-): IMySegmentsUpdater {
-
-  const { segments, largeSegments } = storage;
-  let readyOnAlreadyExistentState = true;
-  let startingUp = true;
-
-  /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
-  function _promiseDecorator<T>(promise: Promise<T>) {
-    if (startingUp) promise = timeout(requestTimeoutBeforeReady, promise);
-    return promise;
-  }
-
-  // @TODO if allowing pluggable storages, handle async execution
-  function updateSegments(segmentsData: IMembershipsResponse | MySegmentsData) {
-
-    let shouldNotifyUpdate;
-    if ((segmentsData as MySegmentsData).type !== undefined) {
-      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIPS_LS_UPDATE ?
-        largeSegments!.resetSegments(segmentsData as MySegmentsData) :
-        segments.resetSegments(segmentsData as MySegmentsData);
-    } else {
-      shouldNotifyUpdate = segments.resetSegments((segmentsData as IMembershipsResponse).ms || {});
-      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData as IMembershipsResponse).ls || {}) || shouldNotifyUpdate;
-    }
-
-    // Notify update if required
-    if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
-      readyOnAlreadyExistentState = false;
-      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
-    }
-  }
-
-  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean, till?: number): Promise<boolean> {
-    const updaterPromise: Promise<boolean> = segmentsData ?
-      // If segmentsData is provided, there is no need to fetch mySegments
-      new Promise((res) => { updateSegments(segmentsData); res(true); }) :
-      // If not provided, fetch mySegments
-      mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(segments => {
-        // Only when we have downloaded segments completely, we should not keep retrying anymore
-        startingUp = false;
-
-        updateSegments(segments);
-        return true;
-      });
-
-    return updaterPromise.catch(error => {
-      if (startingUp && retriesOnFailureBeforeReady > retry) {
-        retry += 1;
-        log.warn(SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
-        return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params
-      } else {
-        startingUp = false;
-      }
-
-      return false;
-    });
-  }
-
-  /**
-   * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
-   * Returned promise will not be rejected.
-   *
-   * @param segmentsData - it can be:
-   *  (1) the list of mySegments names to sync in the storage,
-   *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
-   *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
-   * @param noCache - true to revalidate data to fetch
-   * @param till - query param to bypass CDN requests
-   */
-  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, till?: number) {
-    return _mySegmentsUpdater(0, segmentsData, noCache, till);
-  };
-
-}

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -1,92 +0,0 @@
-import { ISegmentChangesFetcher } from '../fetchers/types';
-import { ISegmentsCacheBase } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
-import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-
-type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
-
-/**
- * Factory of SegmentChanges updater, a task that:
- *  - fetches segment changes using `segmentChangesFetcher`
- *  - updates `segmentsCache`
- *  - uses `segmentsEventEmitter` to emit events related to segments data updates
- *
- * @param log - logger instance
- * @param segmentChangesFetcher - fetcher of `/segmentChanges`
- * @param segments - segments storage, with sync or async methods
- * @param readiness - optional readiness manager. Not required for synchronizer or producer mode.
- */
-export function segmentChangesUpdaterFactory(
-  log: ILogger,
-  segmentChangesFetcher: ISegmentChangesFetcher,
-  segments: ISegmentsCacheBase,
-  readiness?: IReadinessManager,
-): ISegmentChangesUpdater {
-
-  let readyOnAlreadyExistentState = true;
-
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
-    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
-    let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
-
-    return sincePromise.then(since => {
-      // if fetchOnlyNew flag, avoid processing already fetched segments
-      return fetchOnlyNew && since !== undefined ?
-        false :
-        segmentChangesFetcher(since || -1, segmentName, noCache, till).then((changes) => {
-          return Promise.all(changes.map(x => {
-            log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
-            return segments.update(segmentName, x.added, x.removed, x.till);
-          })).then((updates) => {
-            return updates.some(update => update);
-          });
-        });
-    });
-  }
-  /**
-   * Segments updater returns a promise that resolves with a `false` boolean value if it fails at least to fetch a segment or synchronize it with the storage.
-   * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
-   * Returned promise will not be rejected.
-   *
-   * @param fetchOnlyNew - if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
-   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE or RB_SEGMENT_UPDATE notifications.
-   * @param segmentName - segment name to fetch. By passing `undefined` it fetches the list of segments registered at the storage
-   * @param noCache - true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
-   * @param till - till target for the provided segmentName, for CDN bypass.
-   */
-  return function segmentChangesUpdater(fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) {
-    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Started segments update`);
-
-    // If not a segment name provided, read list of available segments names to be updated.
-    let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
-
-    return segmentsPromise.then(segmentNames => {
-      // Async fetchers
-      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
-
-      return Promise.all(updaters).then(shouldUpdateFlags => {
-        // if at least one segment fetch succeeded, mark segments ready
-        if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
-          readyOnAlreadyExistentState = false;
-          if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-        }
-        return true;
-      });
-    })
-      // Handles rejected promises at `segmentChangesFetcher`, `segments.getRegisteredSegments` and other segment storage operations.
-      .catch(error => {
-        if (error && error.statusCode === 403) {
-          // If the operation is forbidden, it may be due to permissions. Destroy the SDK instance.
-          // @TODO although factory status is destroyed, synchronization is not stopped
-          if (readiness) readiness.setDestroyed();
-          log.error(`${LOG_PREFIX_INSTANTIATION}: you passed a client-side type authorizationKey, please grab an SDK Key from the Split user interface that is of type server-side.`);
-        } else {
-          log.warn(`${LOG_PREFIX_SYNC_SEGMENTS}Error while doing fetch of segments. ${error}`);
-        }
-
-        return false;
-      });
-  };
-}

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -1,218 +0,0 @@
-import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
-import { ISplitChangesFetcher } from '../fetchers/types';
-import { IRBSegment, ISplit, ISplitChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
-import { ISplitsEventEmitter } from '../../../readiness/types';
-import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../logger/types';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
-import { startsWith } from '../../../utils/lang';
-import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
-import { setToArray } from '../../../utils/lang/sets';
-import { SPLIT_UPDATE } from '../../streaming/constants';
-
-export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
-type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
-
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
-  let registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-  return registeredSegments.then(segmentNames => {
-    return Promise.all(segmentNames.map(segmentName => segments.getChangeNumber(segmentName)))
-      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== undefined));
-  });
-}
-
-/**
- * Collect segments from a raw FF or RBS definition.
- * Exported for testing purposes.
- */
-export function parseSegments(ruleEntity: ISplit | IRBSegment, matcherType: typeof IN_SEGMENT | typeof IN_RULE_BASED_SEGMENT = IN_SEGMENT): Set<string> {
-  const { conditions = [], excluded } = ruleEntity as IRBSegment;
-
-  const segments = new Set<string>();
-  if (excluded && excluded.segments) {
-    excluded.segments.forEach(({ type, name }) => {
-      if ((type === STANDARD_SEGMENT && matcherType === IN_SEGMENT) || (type === RULE_BASED_SEGMENT && matcherType === IN_RULE_BASED_SEGMENT)) {
-        segments.add(name);
-      }
-    });
-  }
-
-  for (let i = 0; i < conditions.length; i++) {
-    const matchers = conditions[i].matcherGroup.matchers;
-
-    matchers.forEach(matcher => {
-      if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-    });
-  }
-
-  return segments;
-}
-
-interface ISplitMutations<T extends ISplit | IRBSegment> {
-  added: T[],
-  removed: T[]
-}
-
-/**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
- *
- * @param featureFlag - feature flag to be evaluated
- * @param filters - splitFiltersValidation bySet | byName
- */
-function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
-  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
-  if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
-
-  const namesFilterConfigured = namesFilter.length > 0;
-  const prefixFilterConfigured = prefixFilter.length > 0;
-
-  if (!namesFilterConfigured && !prefixFilterConfigured) return true;
-
-  const matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => startsWith(featureFlag.name, prefix));
-  return matchNames || matchPrefix;
-}
-
-/**
- * Given the list of splits from /splitChanges endpoint, it returns the mutations,
- * i.e., an object with added splits, removed splits and used segments.
- * Exported for testing purposes.
- */
-export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>, segments: Set<string>, filters?: ISplitFiltersValidation): ISplitMutations<T> {
-
-  return rules.reduce((accum, ruleEntity) => {
-    if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity as ISplit, filters))) {
-      accum.added.push(ruleEntity);
-
-      parseSegments(ruleEntity).forEach((segmentName: string) => {
-        segments.add(segmentName);
-      });
-    } else {
-      accum.removed.push(ruleEntity);
-    }
-
-    return accum;
-  }, { added: [], removed: [] } as ISplitMutations<T>);
-}
-
-/**
- * factory of SplitChanges updater, a task that:
- *  - fetches split changes using `splitChangesFetcher`
- *  - updates `splitsCache`
- *  - uses `splitsEventEmitter` to emit events related to split data updates
- *
- * @param log -  Logger instance
- * @param splitChangesFetcher -  Fetcher of `/splitChanges`
- * @param splits -  Splits storage, with sync or async methods
- * @param segments -  Segments storage, with sync or async methods
- * @param splitsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
- * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
- * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
- */
-export function splitChangesUpdaterFactory(
-  log: ILogger,
-  splitChangesFetcher: ISplitChangesFetcher,
-  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments'>,
-  splitFiltersValidation: ISplitFiltersValidation,
-  splitsEventEmitter?: ISplitsEventEmitter,
-  requestTimeoutBeforeReady: number = 0,
-  retriesOnFailureBeforeReady: number = 0,
-  isClientSide?: boolean
-): SplitChangesUpdater {
-  const { splits, rbSegments, segments } = storage;
-
-  let startingUp = true;
-
-  /** timeout decorator for `splitChangesFetcher` promise  */
-  function _promiseDecorator<T>(promise: Promise<T>) {
-    if (startingUp && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
-    return promise;
-  }
-
-  /**
-   * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
-   * Returned promise will not be rejected.
-   *
-   * @param noCache - true to revalidate data to fetch
-   * @param till - query param to bypass CDN requests
-   */
-  return function splitChangesUpdater(noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) {
-
-    /**
-     * @param since - current changeNumber at splitsCache
-     * @param retry - current number of retry attempts
-     */
-    function _splitChangesUpdater(sinces: [number, number], retry = 0): Promise<boolean> {
-      const [since, rbSince] = sinces;
-      log.debug(SYNC_SPLITS_FETCH, sinces);
-      return Promise.resolve(
-        instantUpdate ?
-          instantUpdate.type === SPLIT_UPDATE ?
-            // IFFU edge case: a change to a flag that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
-            Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then((contains) => {
-              return contains ?
-                { ff: { d: [instantUpdate.payload as ISplit], t: instantUpdate.changeNumber } } :
-                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
-            }) :
-            { rbs: { d: [instantUpdate.payload as IRBSegment], t: instantUpdate.changeNumber } } :
-          splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
-      )
-        .then((splitChanges: ISplitChangesResponse) => {
-          startingUp = false;
-
-          const usedSegments = new Set<string>();
-
-          let ffUpdate: MaybeThenable<boolean> = false;
-          if (splitChanges.ff) {
-            const { added, removed } = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation);
-            log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
-            ffUpdate = splits.update(added, removed, splitChanges.ff.t);
-          }
-
-          let rbsUpdate: MaybeThenable<boolean> = false;
-          if (splitChanges.rbs) {
-            const { added, removed } = computeMutation(splitChanges.rbs.d, usedSegments);
-            log.debug(SYNC_RBS_UPDATE, [added.length, removed.length]);
-            rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
-          }
-
-          return Promise.all([ffUpdate, rbsUpdate,
-            // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
-            segments.registerSegments(setToArray(usedSegments))
-          ]).then(([ffChanged, rbsChanged]) => {
-            if (splitsEventEmitter) {
-              // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
-                .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                .then(emitSplitsArrivedEvent => {
-                  // emit SDK events
-                  if (emitSplitsArrivedEvent) splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
-                  return true;
-                });
-            }
-            return true;
-          });
-        })
-        .catch(error => {
-          log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
-
-          if (startingUp && retriesOnFailureBeforeReady > retry) {
-            retry += 1;
-            log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-            return _splitChangesUpdater(sinces, retry);
-          } else {
-            startingUp = false;
-          }
-          return false;
-        });
-    }
-
-    // `getChangeNumber` never rejects or throws error
-    return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
-  };
-}

package/src/sync/streaming/AuthClient/index.ts

@@ -1,42 +0,0 @@
-import { IFetchAuth } from '../../../services/types';
-import { IAuthenticate, IAuthToken } from './types';
-import { objectAssign } from '../../../utils/lang/objectAssign';
-import { encodeToBase64 } from '../../../utils/base64';
-import { decodeJWTtoken } from '../../../utils/jwt';
-import { hash } from '../../../utils/murmur3/murmur3';
-
-/**
- * Factory of authentication function.
- *
- * @param fetchAuth - `SplitAPI.fetchAuth` endpoint
- */
-export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
-
-  /**
-   * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-   * @param userKeys - set of user Keys to track membership updates. It is undefined for server-side API.
-   */
-  return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
-    return fetchAuth(userKeys)
-      .then(resp => resp.json())
-      .then(json => {
-        if (json.token) { // empty token when `"pushEnabled": false`
-          const decodedToken = decodeJWTtoken(json.token);
-          if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number') throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
-          const channels = JSON.parse(decodedToken['x-ably-capability']);
-          return objectAssign({
-            decodedToken,
-            channels
-          }, json);
-        }
-        return json;
-      });
-  };
-}
-
-/**
- * Returns the hash of a given user key
- */
-export function hashUserKey(userKey: string): string {
-  return encodeToBase64(hash(userKey, 0).toString());
-}

package/src/sync/streaming/AuthClient/types.ts

@@ -1,20 +0,0 @@
-import { IDecodedJWTToken } from '../../../utils/jwt/types';
-
-export interface IAuthTokenPushEnabled {
-  pushEnabled: true
-  token: string
-  decodedToken: IDecodedJWTToken
-  channels: { [channel: string]: string[] }
-  connDelay?: number
-}
-
-export interface IAuthTokenPushDisabled {
-  pushEnabled: false
-  token: ''
-}
-
-export type IAuthToken = IAuthTokenPushDisabled | IAuthTokenPushEnabled
-
-export type IAuthenticate = (userKeys?: string[]) => Promise<IAuthToken>
-
-export type IAuthenticateV2 = (isClientSide?: boolean) => Promise<IAuthToken>

package/src/sync/streaming/SSEClient/index.ts

@@ -1,103 +0,0 @@
-import { IPlatform } from '../../../sdkFactory/types';
-import { decorateHeaders } from '../../../services/decorateHeaders';
-import { IEventSourceConstructor } from '../../../services/types';
-import { ISettings } from '../../../types';
-import { isString } from '../../../utils/lang';
-import { objectAssign } from '../../../utils/lang/objectAssign';
-import { IAuthTokenPushEnabled } from '../AuthClient/types';
-import { ISSEClient, ISseEventHandler } from './types';
-
-const ABLY_API_VERSION = '1.1';
-
-const CONTROL_CHANNEL_REGEX = /^control_/;
-
-/**
- * Build metadata headers for SSE connection.
- *
- * @param settings - Validated settings.
- * @returns Headers object
- */
-function buildSSEHeaders(settings: ISettings) {
-  const headers: Record<string, string> = {
-    SplitSDKClientKey: isString(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',
-    SplitSDKVersion: settings.version,
-  };
-
-  // ip and hostname are false if IPAddressesEnabled is false
-  const { ip, hostname } = settings.runtime;
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
-
-  return headers;
-}
-
-/**
- * Handles streaming connections with EventSource API
- */
-export class SSEClient implements ISSEClient {
-  // Instance properties:
-  eventSource?: IEventSourceConstructor;
-  connection?: InstanceType<IEventSourceConstructor>;
-  handler?: ISseEventHandler;
-  headers: Record<string, string>;
-  options?: object;
-
-  /**
-   * SSEClient constructor.
-   *
-   * @param settings - Validated settings.
-   * @param platform - object containing environment-specific dependencies
-   * @throws 'EventSource API is not available.' if EventSource is not available.
-   */
-  constructor(private settings: ISettings, { getEventSource, getOptions }: IPlatform) {
-    this.eventSource = getEventSource && getEventSource(settings);
-    // if eventSource is not available, throw an exception
-    if (!this.eventSource) throw new Error('EventSource API is not available.');
-
-    this.headers = buildSSEHeaders(settings);
-    this.options = getOptions && getOptions(settings);
-  }
-
-  setEventHandler(handler: ISseEventHandler) {
-    this.handler = handler;
-  }
-
-  /**
-   * Open the connection with a given authToken
-   */
-  open(authToken: IAuthTokenPushEnabled) {
-    this.close(); // it closes connection if previously opened
-
-    const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {
-      const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-      return encodeURIComponent(params + channel);
-    }).join(',');
-    const url = `${this.settings.urls.streaming}/sse?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
-    const isServerSide = !this.settings.core.key;
-
-    this.connection = new this.eventSource!(
-      // For client-side SDKs, metadata is passed as query param to avoid CORS issues and because native EventSource implementations in browsers do not support headers
-      isServerSide ? url : url + `&SplitSDKVersion=${this.headers.SplitSDKVersion}&SplitSDKClientKey=${this.headers.SplitSDKClientKey}`,
-      // For server-side SDKs, metadata is passed via headers
-      objectAssign(
-        isServerSide ?
-          { headers: decorateHeaders(this.settings, this.headers) } :
-          this.settings.sync.requestOptions?.getHeaderOverrides ?
-            { headers: decorateHeaders(this.settings, {}) } : // User must provide a window.EventSource polyfill that supports headers
-            {},
-        this.options
-      )
-    );
-
-    if (this.handler) { // no need to check if SSEClient is used only by PushManager
-      this.connection.addEventListener('open', this.handler.handleOpen);
-      this.connection.addEventListener('message', this.handler.handleMessage);
-      this.connection.addEventListener('error', this.handler.handleError);
-    }
-  }
-
-  /** Close connection  */
-  close() {
-    if (this.connection) this.connection.close();
-  }
-}

package/src/sync/streaming/SSEClient/types.ts

@@ -1,13 +0,0 @@
-import { IAuthTokenPushEnabled } from '../AuthClient/types';
-
-export interface ISseEventHandler {
-  handleError: (ev: Event) => any;
-  handleMessage: (ev: MessageEvent) => any;
-  handleOpen: () => any;
-}
-
-export interface ISSEClient {
-  open(authToken: IAuthTokenPushEnabled): void,
-  close(): void,
-  setEventHandler(handler: ISseEventHandler): void
-}