@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -1,72 +0,0 @@
-import { ISplitPartial } from '../../../dtos/types';
-import SplitIO from '../../../../types/splitio';
-import { isObject, forOwn, merge } from '../../../utils/lang';
-import { parseCondition } from './parseCondition';
-
-function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
-  if (typeof prev !== typeof curr) return true;
-
-  if (typeof prev === 'string') { // strings treatments, just compare
-    return prev !== curr;
-  } else { // has treatment and config, compare both
-    return prev.treatment !== (curr as SplitIO.TreatmentWithConfig).treatment || prev.config !== (curr as SplitIO.TreatmentWithConfig).config;
-  }
-}
-
-export function splitsParserFromSettingsFactory() {
-
-  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
-
-  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
-    const names = Object.keys(currentData);
-
-    // Different amount of items
-    if (names.length !== Object.keys(previousMock).length) {
-      previousMock = merge({}, currentData) as SplitIO.MockedFeaturesMap;
-      return true;
-    }
-
-    return names.some(name => {
-      const newSplit = !previousMock[name];
-      const newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-      const changed = newSplit || newTreatment;
-
-      if (changed) previousMock = merge({}, currentData) as SplitIO.MockedFeaturesMap;
-
-      return changed;
-    });
-  }
-
-  /**
-   *
-   * @param settings - validated object with mocked features mapping.
-   */
-  return function splitsParserFromSettings(settings: Pick<SplitIO.ISettings, 'features'>): false | Record<string, ISplitPartial> {
-    const features = settings.features as SplitIO.MockedFeaturesMap || {};
-
-    if (!mockUpdated(features)) return false;
-
-    const splitObjects: Record<string, ISplitPartial> = {};
-
-    forOwn(features, (data, splitName) => {
-      let treatment = data;
-      let config = null;
-
-      if (isObject(data)) {
-        treatment = (data as SplitIO.TreatmentWithConfig).treatment;
-        config = (data as SplitIO.TreatmentWithConfig).config || config;
-      }
-      const configurations: Record<string, string> = {};
-      if (config !== null) configurations[treatment as string] = config;
-
-      splitObjects[splitName] = {
-        trafficTypeName: 'localhost',
-        conditions: [parseCondition({ treatment: treatment as string })],
-        configurations
-      };
-    });
-
-    return splitObjects;
-  };
-
-}

package/src/sync/offline/splitsParser/types.ts

@@ -1,5 +0,0 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { ISettings } from '../../../types';
-
-// Analog to `ISplitChangesFetcher` used by `splitChangesUpdaterFactory`
-export type ISplitsParser = (settings: ISettings) => false | Record<string, ISplitPartial>

package/src/sync/offline/syncManagerOffline.ts

@@ -1,66 +0,0 @@
-import { ISyncManagerCS } from '../types';
-import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
-import { objectAssign } from '../../utils/lang/objectAssign';
-import { ISplitsParser } from './splitsParser/types';
-import { IReadinessManager } from '../../readiness/types';
-import { SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-
-function flush() {
-  return Promise.resolve();
-}
-
-/**
- * Offline SyncManager factory.
- * Can be used for server-side API, and client-side API with or without multiple clients.
- *
- * @param splitsParser - e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
- */
-export function syncManagerOfflineFactory(
-  splitsParserFactory: () => ISplitsParser
-): (params: ISdkFactoryContextSync) => ISyncManagerCS {
-
-  /**
-   * SyncManager factory for modular SDK
-   */
-  return function ({
-    settings,
-    readiness,
-    storage,
-  }: ISdkFactoryContextSync): ISyncManagerCS {
-
-    const mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
-    const mainStart = mainSyncManager.start;
-    const sharedStarts: Array<() => void> = [];
-
-    return objectAssign(
-      mainSyncManager,
-      {
-        start() {
-          mainStart();
-          sharedStarts.forEach(cb => cb());
-          sharedStarts.length = 0;
-        },
-        // fake flush, that resolves immediately
-        flush,
-
-        // [Only used for client-side]
-        shared(matchingKey: string, readinessManager: IReadinessManager) {
-          // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-          // SDK_READY cannot be emitted directly because this will not update the readiness status
-          function emitSdkReady() {
-            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-          }
-
-          if (mainSyncManager.isRunning()) setTimeout(emitSdkReady);
-          else sharedStarts.push(emitSdkReady);
-
-          return {
-            stop() { },
-            flush,
-          };
-        }
-      }
-    );
-  };
-}

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -1,97 +0,0 @@
-import { forOwn } from '../../../utils/lang';
-import { IReadinessManager } from '../../../readiness/types';
-import { IStorageSync } from '../../../storages/types';
-import { ISplitsParser } from '../splitsParser/types';
-import { ISplit, ISplitPartial } from '../../../dtos/types';
-import { syncTaskFactory } from '../../syncTask';
-import { ISyncTask } from '../../types';
-import { ISettings } from '../../../types';
-import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
-import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
-
-/**
- * Offline equivalent of `splitChangesUpdaterFactory`
- */
-export function fromObjectUpdaterFactory(
-  splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
-  readiness: IReadinessManager,
-  settings: ISettings,
-): () => Promise<boolean> {
-
-  const log = settings.log, splitsCache = storage.splits;
-  let startingUp = true;
-
-  return function objectUpdater() {
-    const splits: ISplit[] = [];
-    let loadError = null;
-    let splitsMock: false | Record<string, ISplitPartial> = {};
-    try {
-      splitsMock = splitsParser(settings);
-    } catch (err) {
-      loadError = err;
-      log.error(ERROR_SYNC_OFFLINE_LOADING, [err]);
-    }
-
-    if (!loadError && splitsMock) {
-      log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
-
-      forOwn(splitsMock, (val, name) => {
-        // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-        splits.push({
-          name,
-          status: 'ACTIVE',
-          killed: false,
-          trafficAllocation: 100,
-          defaultTreatment: CONTROL,
-          conditions: val.conditions || [],
-          configurations: val.configurations,
-          trafficTypeName: val.trafficTypeName
-        });
-      });
-
-      return Promise.all([
-        splitsCache.clear(), // required to sync removed splits from mock
-        splitsCache.update(splits, [], Date.now())
-      ]).then(() => {
-        readiness.splits.emit(SDK_SPLITS_ARRIVED);
-
-        if (startingUp) {
-          startingUp = false;
-          Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
-            // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-            // Emits SDK_READY
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-          });
-        }
-        return true;
-      });
-    } else {
-      return Promise.resolve(true);
-    }
-  };
-}
-
-/**
- * PollingManager in Offline mode
- */
-export function fromObjectSyncTaskFactory(
-  splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
-  readiness: IReadinessManager,
-  settings: ISettings
-): ISyncTask<[], boolean> {
-  return syncTaskFactory(
-    settings.log,
-    fromObjectUpdaterFactory(
-      splitsParser,
-      storage,
-      readiness,
-      settings,
-    ),
-    settings.scheduler.offlineRefreshRate,
-    'offlineUpdater',
-  );
-}

package/src/sync/polling/fetchers/mySegmentsFetcher.ts

@@ -1,25 +0,0 @@
-import { IFetchMemberships, IResponse } from '../../../services/types';
-import { IMembershipsResponse } from '../../../dtos/types';
-import { IMySegmentsFetcher } from './types';
-
-/**
- * Factory of MySegments fetcher.
- * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
- */
-export function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): IMySegmentsFetcher {
-
-  return function mySegmentsFetcher(
-    userMatchingKey: string,
-    noCache?: boolean,
-    till?: number,
-    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
-    decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-  ): Promise<IMembershipsResponse> {
-
-    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
-    if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
-
-    return mySegmentsPromise.then(resp => resp.json());
-  };
-
-}

package/src/sync/polling/fetchers/segmentChangesFetcher.ts

@@ -1,41 +0,0 @@
-import { IFetchSegmentChanges } from '../../../services/types';
-import { ISegmentChangesResponse } from '../../../dtos/types';
-import { ISegmentChangesFetcher } from './types';
-
-function greedyFetch(fetchSegmentChanges: IFetchSegmentChanges, since: number, segmentName: string, noCache?: boolean, targetTill?: number): Promise<ISegmentChangesResponse[]> {
-  return fetchSegmentChanges(since, segmentName, noCache, targetTill)
-    .then(resp => resp.json())
-    .then((json: ISegmentChangesResponse) => {
-      let { since, till } = json;
-      if (since === till) {
-        return [json];
-      } else {
-        return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache, targetTill)]).then(flatMe => {
-          return [flatMe[0], ...flatMe[1]];
-        });
-      }
-    });
-}
-
-/**
- * Factory of SegmentChanges fetcher.
- * SegmentChanges fetcher is a wrapper around `segmentChanges` API service that parses the response and handle errors and retries.
- */
-export function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentChanges): ISegmentChangesFetcher {
-
-  return function segmentChangesFetcher(
-    since: number,
-    segmentName: string,
-    noCache?: boolean,
-    till?: number,
-    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
-    decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
-  ): Promise<ISegmentChangesResponse[]> {
-
-    let segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
-    if (decorator) segmentsPromise = decorator(segmentsPromise);
-
-    return segmentsPromise;
-  };
-
-}

package/src/sync/polling/fetchers/splitChangesFetcher.ts

@@ -1,85 +0,0 @@
-import { ISettings } from '../../../types';
-import { ISplitChangesResponse } from '../../../dtos/types';
-import { IFetchSplitChanges, IResponse } from '../../../services/types';
-import { IStorageBase } from '../../../storages/types';
-import { FLAG_SPEC_VERSION } from '../../../utils/constants';
-import { base } from '../../../utils/settingsValidation';
-import { ISplitChangesFetcher } from './types';
-import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
-
-const PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
-const PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
-
-function sdkEndpointOverridden(settings: ISettings) {
-  return settings.urls.sdk !== base.urls.sdk;
-}
-
-/**
- * Factory of SplitChanges fetcher.
- * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
- */
-// @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
-export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges, settings: ISettings, storage: Pick<IStorageBase, 'splits' | 'rbSegments'>): ISplitChangesFetcher {
-
-  const log = settings.log;
-  const PROXY_CHECK_INTERVAL_MILLIS = settings.core.key !== undefined ? PROXY_CHECK_INTERVAL_MILLIS_CS : PROXY_CHECK_INTERVAL_MILLIS_SS;
-  let lastProxyCheckTimestamp: number | undefined;
-
-  return function splitChangesFetcher(
-    since: number,
-    noCache?: boolean,
-    till?: number,
-    rbSince?: number,
-    // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
-    decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-  ): Promise<ISplitChangesResponse> {
-
-    // Recheck proxy
-    if (lastProxyCheckTimestamp && (Date.now() - lastProxyCheckTimestamp) > PROXY_CHECK_INTERVAL_MILLIS) {
-      settings.sync.flagSpecVersion = FLAG_SPEC_VERSION;
-    }
-
-    let splitsPromise = fetchSplitChanges(since, noCache, till, settings.sync.flagSpecVersion === FLAG_SPEC_VERSION ? rbSince : undefined)
-      .catch((err) => {
-        // Handle proxy error with spec 1.3
-        if ((!err.statusCode || err.statusCode === 400) && sdkEndpointOverridden(settings) && settings.sync.flagSpecVersion === FLAG_SPEC_VERSION) {
-          log.error(LOG_PREFIX_SYNC_SPLITS + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
-          lastProxyCheckTimestamp = Date.now();
-          settings.sync.flagSpecVersion = '1.2'; // fallback to 1.2 spec
-          return fetchSplitChanges(since, noCache, till); // retry request without rbSince
-        }
-        throw err;
-      });
-
-    if (decorator) splitsPromise = decorator(splitsPromise);
-
-    return splitsPromise
-      .then(resp => resp.json())
-      .then(data => {
-        // Using flag spec version 1.2 or below
-        if (data.splits) {
-          return {
-            ff: {
-              d: data.splits,
-              s: data.since,
-              t: data.till
-            }
-          };
-        }
-
-        // Proxy recovery
-        if (lastProxyCheckTimestamp) {
-          log.info(LOG_PREFIX_SYNC_SPLITS + 'Proxy error recovered');
-          lastProxyCheckTimestamp = undefined;
-          return splitChangesFetcher(-1, undefined, undefined, -1)
-            .then((splitChangesResponse: ISplitChangesResponse) =>
-              Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
-                .then(() => splitChangesResponse)
-            );
-        }
-
-        return data;
-      });
-  };
-
-}

package/src/sync/polling/fetchers/types.ts

@@ -1,25 +0,0 @@
-import { ISplitChangesResponse, ISegmentChangesResponse, IMembershipsResponse } from '../../../dtos/types';
-import { IResponse } from '../../../services/types';
-
-export type ISplitChangesFetcher = (
-  since: number,
-  noCache?: boolean,
-  till?: number,
-  rbSince?: number,
-  decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-) => Promise<ISplitChangesResponse>
-
-export type ISegmentChangesFetcher = (
-  since: number,
-  segmentName: string,
-  noCache?: boolean,
-  till?: number,
-  decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
-) => Promise<ISegmentChangesResponse[]>
-
-export type IMySegmentsFetcher = (
-  userMatchingKey: string,
-  noCache?: boolean,
-  till?: number,
-  decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-) => Promise<IMembershipsResponse>

package/src/sync/polling/pollingManagerCS.ts

@@ -1,116 +0,0 @@
-import { IMySegmentsSyncTask, IPollingManagerCS } from './types';
-import { forOwn } from '../../utils/lang';
-import { IReadinessManager } from '../../readiness/types';
-import { IStorageSync } from '../../storages/types';
-import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
-import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
-import { getMatching } from '../../utils/key';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
-
-/**
- * Expose start / stop mechanism for polling data from services.
- * For client-side API with multiple clients.
- */
-export function pollingManagerCSFactory(
-  params: ISdkFactoryContextSync
-): IPollingManagerCS {
-
-  const { splitApi, storage, readiness, settings } = params;
-  const log = settings.log;
-
-  const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
-
-  // Map of matching keys to their corresponding MySegmentsSyncTask.
-  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
-
-  const matchingKey = getMatching(settings.core.key);
-  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
-
-  function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-      mySegmentsSyncTask.start();
-    });
-  }
-
-  function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-      if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
-    });
-  }
-
-  // smart pausing
-  readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
-    const usingSegments = usesSegmentsSync(storage);
-    if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-      log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-      if (usingSegments) {
-        startMySegmentsSyncTasks();
-      } else {
-        stopMySegmentsSyncTasks();
-      }
-    }
-  });
-
-  function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
-
-    // smart ready
-    function smartReady() {
-      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-    }
-    if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
-    else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-
-    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-    return mySegmentsSyncTask;
-  }
-
-  return {
-    splitsSyncTask,
-    segmentsSyncTask: mySegmentsSyncTask,
-
-    // Start periodic fetching (polling)
-    start() {
-      log.info(POLLING_START);
-
-      splitsSyncTask.start();
-      if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
-    },
-
-    // Stop periodic fetching (polling)
-    stop() {
-      log.info(POLLING_STOP);
-
-      if (splitsSyncTask.isRunning()) splitsSyncTask.stop();
-      stopMySegmentsSyncTasks();
-    },
-
-    // Used by SyncManager to know if running in polling mode.
-    isRunning: splitsSyncTask.isRunning,
-
-    // fetch splits and segments
-    syncAll() {
-      const promises = [splitsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-        promises.push(mySegmentsSyncTask.execute());
-      });
-      return Promise.all(promises);
-    },
-
-    // Support for handling mySegments sync of multiple clients
-    add,
-
-    remove(matchingKey: string) {
-      delete mySegmentsSyncTasks[matchingKey];
-    },
-
-    get(matchingKey: string) {
-      return mySegmentsSyncTasks[matchingKey];
-    }
-  };
-
-}

package/src/sync/polling/pollingManagerSS.ts

@@ -1,56 +0,0 @@
-import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
-import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types';
-import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-
-/**
- * Expose start / stop mechanism for pulling data from services.
- */
-export function pollingManagerSSFactory(
-  params: ISdkFactoryContextSync
-): IPollingManager {
-
-  const { splitApi, storage, readiness, settings } = params;
-  const log = settings.log;
-
-  const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
-  const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);
-
-  return {
-    splitsSyncTask,
-    segmentsSyncTask,
-
-    // Start periodic fetching (polling)
-    start() {
-      log.info(POLLING_START);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `Splits will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
-
-      const startingUp = splitsSyncTask.start();
-      if (startingUp) {
-        startingUp.then(() => {
-          if (splitsSyncTask.isRunning()) segmentsSyncTask.start();
-        });
-      }
-    },
-
-    // Stop periodic fetching (polling)
-    stop() {
-      log.info(POLLING_STOP);
-
-      if (splitsSyncTask.isRunning()) splitsSyncTask.stop();
-      if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop();
-    },
-
-    // Used by SyncManager to know if running in polling mode.
-    isRunning: splitsSyncTask.isRunning,
-
-    syncAll() {
-      // fetch splits and segments. There is no need to catch this promise (`SplitChangesUpdater` is always resolved with a boolean value)
-      return splitsSyncTask.execute().then(() => {
-        return segmentsSyncTask.execute();
-      });
-    }
-  };
-}

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

@@ -1,34 +0,0 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { syncTaskFactory } from '../../syncTask';
-import { IMySegmentsSyncTask } from '../types';
-import { IFetchMemberships } from '../../../services/types';
-import { mySegmentsFetcherFactory } from '../fetchers/mySegmentsFetcher';
-import { ISettings } from '../../../types';
-import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
-
-/**
- * Creates a sync task that periodically executes a `mySegmentsUpdater` task
- */
-export function mySegmentsSyncTaskFactory(
-  fetchMemberships: IFetchMemberships,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings,
-  matchingKey: string
-): IMySegmentsSyncTask {
-  return syncTaskFactory(
-    settings.log,
-    mySegmentsUpdaterFactory(
-      settings.log,
-      mySegmentsFetcherFactory(fetchMemberships),
-      storage,
-      readiness.segments,
-      settings.startup.requestTimeoutBeforeReady,
-      settings.startup.retriesOnFailureBeforeReady,
-      matchingKey
-    ),
-    settings.scheduler.segmentsRefreshRate,
-    'mySegmentsUpdater',
-  );
-}

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

@@ -1,30 +0,0 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { syncTaskFactory } from '../../syncTask';
-import { ISegmentsSyncTask } from '../types';
-import { segmentChangesFetcherFactory } from '../fetchers/segmentChangesFetcher';
-import { IFetchSegmentChanges } from '../../../services/types';
-import { ISettings } from '../../../types';
-import { segmentChangesUpdaterFactory } from '../updaters/segmentChangesUpdater';
-
-/**
- * Creates a sync task that periodically executes a `segmentChangesUpdater` task
- */
-export function segmentsSyncTaskFactory(
-  fetchSegmentChanges: IFetchSegmentChanges,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings,
-): ISegmentsSyncTask {
-  return syncTaskFactory(
-    settings.log,
-    segmentChangesUpdaterFactory(
-      settings.log,
-      segmentChangesFetcherFactory(fetchSegmentChanges),
-      storage.segments,
-      readiness,
-    ),
-    settings.scheduler.segmentsRefreshRate,
-    'segmentChangesUpdater'
-  );
-}