Additional changes after contract tests integration

Author: tanderson-ld

packages/shared/common/src/datasource/CompositeDataSource.ts

@@ -29,7 +29,6 @@ interface TransitionRequest {
   err?: Error;
 }
 
-// TODO SDK-858: move this out of API directory to neighbor datasource folder
 /**
  * The {@link CompositeDataSource} can combine a number of {@link DataSystemInitializer}s and {@link DataSystemSynchronizer}s
  * into a single {@link DataSource}, implementing fallback and recovery logic internally to choose where data is sourced from.

packages/shared/sdk-server/src/LDClientImpl.ts

@@ -31,9 +31,9 @@ import { Hook } from './api/integrations/Hook';
 import { BigSegmentStoreMembership } from './api/interfaces';
 import { LDWaitForInitializationOptions } from './api/LDWaitForInitializationOptions';
 import {
-  isPollingOptions,
+  isPollingOnlyOptions,
   isStandardOptions,
-  isStreamingOptions,
+  isStreamingOnlyOptions,
 } from './api/options/LDDataSystemOptions';
 import BigSegmentsManager from './BigSegmentsManager';
 import BigSegmentStoreStatusProvider from './BigSegmentStatusProviderImpl';
@@ -225,7 +225,7 @@ export default class LDClientImpl implements LDClient {
       put: () => this._initSuccess(),
     });
     const makeDefaultProcessor = () => {
-      if (isPollingOptions(config.dataSystem.dataSource)) {
+      if (isPollingOnlyOptions(config.dataSystem.dataSource)) {
         return new PollingProcessor(
           new Requestor(config, this._platform.requests, baseHeaders),
           config.dataSystem.dataSource.pollInterval ?? 30,
@@ -238,7 +238,7 @@ export default class LDClientImpl implements LDClient {
       // TODO: SDK-858 Hook up composite data source and config
       const reconnectDelay =
         isStandardOptions(config.dataSystem.dataSource) ||
-        isStreamingOptions(config.dataSystem.dataSource)
+        isStreamingOnlyOptions(config.dataSystem.dataSource)
           ? config.dataSystem.dataSource.streamInitialReconnectDelay
           : 1;
       return new StreamingProcessor(

packages/shared/sdk-server/src/api/options/LDDataSystemOptions.ts

@@ -21,7 +21,7 @@ import { PersistentDataStore } from '../interfaces';
  *
  * let dataSystemOptions = {
  *     dataSource: {
- *         type: 'polling';
+ *         type: 'pollingOnly';
  *         pollInterval: 300;
  *     },
  *     persistentStore: DynamoDBFeatureStore('your-table', { cacheTTL: 30 });
@@ -116,7 +116,7 @@ export interface StandardDataSourceOptions {
  * to provide real time data updates.
  */
 export interface StreamingDataSourceOptions {
-  type: 'streaming';
+  type: 'streamingOnly';
 
   /**
    * Sets the initial reconnect delay for the streaming connection, in seconds. Default if omitted.
@@ -134,7 +134,7 @@ export interface StreamingDataSourceOptions {
  * This data source will periodically make a request to LaunchDarkly services to retrieve updated data.
  */
 export interface PollingDataSourceOptions {
-  type: 'polling';
+  type: 'pollingOnly';
 
   /**
    * The time between polling requests, in seconds. Default if omitted.
@@ -146,10 +146,10 @@ export function isStandardOptions(u: any): u is StandardDataSourceOptions {
   return u.type === 'standard';
 }
 
-export function isStreamingOptions(u: any): u is StreamingDataSourceOptions {
-  return u.type === 'streaming';
+export function isStreamingOnlyOptions(u: any): u is StreamingDataSourceOptions {
+  return u.type === 'streamingOnly';
 }
 
-export function isPollingOptions(u: any): u is PollingDataSourceOptions {
-  return u.type === 'polling';
+export function isPollingOnlyOptions(u: any): u is PollingDataSourceOptions {
+  return u.type === 'pollingOnly';
 }

packages/shared/sdk-server/src/api/options/LDOptions.ts

@@ -100,7 +100,7 @@ export interface LDOptions {
    *
    * let dataSystemOptions = {
    *     dataSource: {
-   *         type: 'polling';
+   *         type: 'pollingOnly';
    *         pollInterval: 300;
    *     },
    *     persistentStore: DynamoDBFeatureStore('your-table', { cacheTTL: 30 });

packages/shared/sdk-server/src/data_sources/PollingProcessor.ts

@@ -9,11 +9,9 @@ import {
 } from '@launchdarkly/js-sdk-common';
 
 import { LDDataSourceUpdates } from '../api/subsystems';
-import Configuration from '../options/Configuration';
 import { deserializePoll } from '../store';
 import VersionedDataKinds from '../store/VersionedDataKinds';
 import Requestor from './Requestor';
-import { isPollingOptions, isStandardOptions } from '../api/options/LDDataSystemOptions';
 
 export type PollingErrorHandler = (err: LDPollingError) => void;
 

packages/shared/sdk-server/src/diagnostics/createDiagnosticsInitConfig.ts

@@ -1,6 +1,11 @@
 import { Platform, secondsToMillis } from '@launchdarkly/js-sdk-common';
 
-import { isPollingOptions, isStandardOptions, isStreamingOptions, LDFeatureStore } from '../api';
+import {
+  isPollingOnlyOptions,
+  isStandardOptions,
+  isStreamingOnlyOptions,
+  LDFeatureStore,
+} from '../api';
 import Configuration, { defaultValues } from '../options/Configuration';
 
 const createDiagnosticsInitConfig = (
@@ -20,20 +25,20 @@ const createDiagnosticsInitConfig = (
   eventsFlushIntervalMillis: secondsToMillis(config.flushInterval),
   // include polling interval if data source config has it
   ...((isStandardOptions(config.dataSystem.dataSource) ||
-    isPollingOptions(config.dataSystem.dataSource)) &&
+    isPollingOnlyOptions(config.dataSystem.dataSource)) &&
   config.dataSystem.dataSource.pollInterval
     ? { pollingIntervalMillis: config.dataSystem.dataSource.pollInterval }
     : null),
   // include reconnect delay if data source config has it
   ...((isStandardOptions(config.dataSystem.dataSource) ||
-    isStreamingOptions(config.dataSystem.dataSource)) &&
+    isStreamingOnlyOptions(config.dataSystem.dataSource)) &&
   config.dataSystem.dataSource.streamInitialReconnectDelay
     ? { reconnectTimeMillis: config.dataSystem.dataSource.streamInitialReconnectDelay }
     : null),
   contextKeysFlushIntervalMillis: secondsToMillis(config.contextKeysFlushInterval),
   diagnosticRecordingIntervalMillis: secondsToMillis(config.diagnosticRecordingInterval),
 
-  streamingDisabled: isPollingOptions(config.dataSystem.dataSource),
+  streamingDisabled: isPollingOnlyOptions(config.dataSystem.dataSource),
   usingRelayDaemon: config.useLdd,
   offline: config.offline,
   allAttributesPrivate: config.allAttributesPrivate,

packages/shared/sdk-server/src/options/Configuration.ts

@@ -16,16 +16,15 @@ import { LDBigSegmentsOptions, LDOptions, LDProxyOptions, LDTLSOptions } from '.
 import { Hook } from '../api/integrations';
 import {
   DataSourceOptions,
-  isPollingOptions,
+  isPollingOnlyOptions,
   isStandardOptions,
-  isStreamingOptions,
+  isStreamingOnlyOptions,
   LDDataSystemOptions,
   PollingDataSourceOptions,
   StandardDataSourceOptions,
   StreamingDataSourceOptions,
 } from '../api/options/LDDataSystemOptions';
 import { LDDataSourceUpdates, LDFeatureStore } from '../api/subsystems';
-import { PersistentDataStoreWrapper } from '../store';
 import InMemoryFeatureStore from '../store/InMemoryFeatureStore';
 import { ValidatedOptions } from './ValidatedOptions';
 
@@ -82,12 +81,12 @@ const defaultStandardDataSourceOptions: StandardDataSourceOptions = {
 };
 
 const defaultStreamingDataSourceOptions: StreamingDataSourceOptions = {
-  type: 'streaming',
+  type: 'streamingOnly',
   streamInitialReconnectDelay: DEFAULT_STREAM_RECONNECT_DELAY,
 };
 
 const defaultPollingDataSourceOptions: PollingDataSourceOptions = {
-  type: 'polling',
+  type: 'pollingOnly',
   pollInterval: DEFAULT_POLL_INTERVAL,
 };
 
@@ -232,12 +231,12 @@ function validateDataSystemOptions(options: Options): {
         options.dataSource,
         defaultStandardDataSourceOptions,
       ));
-    } else if (isStreamingOptions(options.dataSource)) {
+    } else if (isStreamingOnlyOptions(options.dataSource)) {
       ({ errors, validatedOptions: validatedDataSourceOptions } = validateTypesAndNames(
         options.dataSource,
         defaultStreamingDataSourceOptions,
       ));
-    } else if (isPollingOptions(options.dataSource)) {
+    } else if (isPollingOnlyOptions(options.dataSource)) {
       ({ errors, validatedOptions: validatedDataSourceOptions } = validateTypesAndNames(
         options.dataSource,
         defaultPollingDataSourceOptions,
@@ -395,7 +394,7 @@ export default class Configuration {
                 pollInterval: validatedOptions.pollInterval,
               }
             : {
-                type: 'polling',
+                type: 'pollingOnly',
                 pollInterval: validatedOptions.pollInterval,
               },
         useLdd: validatedOptions.useLdd,