feat: adds datasource status to sdk-client

packages/shared/common/src/errors.ts

@@ -2,33 +2,6 @@
 // more complex, then they could be independent files.
 /* eslint-disable max-classes-per-file */
 
-export class LDFileDataSourceError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'LaunchDarklyFileDataSourceError';
-  }
-}
-
-export class LDPollingError extends Error {
-  public readonly status?: number;
-
-  constructor(message: string, status?: number) {
-    super(message);
-    this.status = status;
-    this.name = 'LaunchDarklyPollingError';
-  }
-}
-
-export class LDStreamingError extends Error {
-  public readonly code?: number;
-
-  constructor(message: string, code?: number) {
-    super(message);
-    this.code = code;
-    this.name = 'LaunchDarklyStreamingError';
-  }
-}
-
 export class LDUnexpectedResponseError extends Error {
   constructor(message: string) {
     super(message);

packages/shared/common/src/internal/datasource/DataSourceErrorKinds.ts

@@ -0,0 +1,15 @@
+export enum DataSourceErrorKind {
+  /// An unexpected error, such as an uncaught exception, further
+  /// described by the error message.
+  Unknown,
+
+  /// An I/O error such as a dropped connection.
+  NetworkError,
+
+  /// The LaunchDarkly service returned an HTTP response with an error
+  /// status, available in the status code.
+  ErrorResponse,
+
+  /// The SDK received malformed data from the LaunchDarkly service.
+  InvalidData,
+}

packages/shared/common/src/internal/datasource/errors.ts

@@ -0,0 +1,39 @@
+/* eslint-disable max-classes-per-file */
+import { DataSourceErrorKind } from './DataSourceErrorKinds';
+
+export class LDFileDataSourceError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'LaunchDarklyFileDataSourceError';
+  }
+}
+
+export class LDPollingError extends Error {
+  public readonly kind: DataSourceErrorKind;
+  public readonly status?: number;
+  public readonly recoverable: boolean;
+
+  constructor(kind: DataSourceErrorKind, message: string, status?: number, recoverable = true) {
+    super(message);
+    this.kind = kind;
+    this.status = status;
+    this.name = 'LaunchDarklyPollingError';
+    this.recoverable = recoverable;
+  }
+}
+
+export class LDStreamingError extends Error {
+  public readonly kind: DataSourceErrorKind;
+  public readonly code?: number;
+  public readonly recoverable: boolean;
+
+  constructor(kind: DataSourceErrorKind, message: string, code?: number, recoverable = true) {
+    super(message);
+    this.kind = kind;
+    this.code = code;
+    this.name = 'LaunchDarklyStreamingError';
+    this.recoverable = recoverable;
+  }
+}
+
+export type StreamingErrorHandler = (err: LDStreamingError) => void;

packages/shared/common/src/internal/datasource/index.ts

@@ -0,0 +1,15 @@
+import { DataSourceErrorKind } from './DataSourceErrorKinds';
+import {
+  LDFileDataSourceError,
+  LDPollingError,
+  LDStreamingError,
+  StreamingErrorHandler,
+} from './errors';
+
+export {
+  DataSourceErrorKind,
+  LDFileDataSourceError,
+  LDPollingError,
+  LDStreamingError,
+  StreamingErrorHandler,
+};

packages/shared/common/src/internal/index.ts

@@ -1,5 +1,6 @@
+export * from './context';
+export * from './datasource';
 export * from './diagnostics';
 export * from './evaluation';
 export * from './events';
 export * from './stream';
-export * from './context';

packages/shared/common/src/internal/stream/StreamingProcessor.test.ts

@@ -2,8 +2,9 @@ import { createBasicPlatform, createLogger } from '@launchdarkly/private-js-mock
 
 import { EventName, Info, LDLogger, ProcessStreamResponse } from '../../api';
 import { LDStreamProcessor } from '../../api/subsystem';
-import { LDStreamingError } from '../../errors';
 import { defaultHeaders } from '../../utils';
+import { DataSourceErrorKind } from '../datasource/DataSourceErrorKinds';
+import { LDStreamingError } from '../datasource/errors';
 import { DiagnosticsManager } from '../diagnostics';
 import StreamingProcessor from './StreamingProcessor';
 
@@ -260,7 +261,7 @@ describe('given a stream processor with mock event source', () => {
 
       expect(willRetry).toBeFalsy();
       expect(mockErrorHandler).toBeCalledWith(
-        new LDStreamingError(testError.message, testError.status),
+        new LDStreamingError(DataSourceErrorKind.Unknown, testError.message, testError.status),
       );
       expect(logger.error).toBeCalledWith(
         expect.stringMatching(new RegExp(`${status}.*permanently`)),

packages/shared/common/src/internal/stream/StreamingProcessor.ts

@@ -7,12 +7,12 @@ import {
   Requests,
 } from '../../api';
 import { LDStreamProcessor } from '../../api/subsystem';
-import { LDStreamingError } from '../../errors';
 import { ClientContext } from '../../options';
 import { getStreamingUri } from '../../options/ServiceEndpoints';
 import { httpErrorMessage, LDHeaders, shouldRetry } from '../../utils';
+import { DataSourceErrorKind } from '../datasource/DataSourceErrorKinds';
+import { LDStreamingError, StreamingErrorHandler } from '../datasource/errors';
 import { DiagnosticsManager } from '../diagnostics';
-import { StreamingErrorHandler } from './types';
 
 const reportJsonError = (
   type: string,
@@ -22,7 +22,9 @@ const reportJsonError = (
 ) => {
   logger?.error(`Stream received invalid data in "${type}" message`);
   logger?.debug(`Invalid JSON follows: ${data}`);
-  errorHandler?.(new LDStreamingError('Malformed JSON data in event stream'));
+  errorHandler?.(
+    new LDStreamingError(DataSourceErrorKind.InvalidData, 'Malformed JSON data in event stream'),
+  );
 };
 
 // TODO: SDK-156 - Move to Server SDK specific location
@@ -87,7 +89,9 @@ class StreamingProcessor implements LDStreamProcessor {
   private retryAndHandleError(err: HttpErrorResponse) {
     if (!shouldRetry(err)) {
       this.logConnectionResult(false);
-      this.errorHandler?.(new LDStreamingError(err.message, err.status));
+      this.errorHandler?.(
+        new LDStreamingError(DataSourceErrorKind.ErrorResponse, err.message, err.status),
+      );
       this.logger?.error(httpErrorMessage(err, 'streaming request'));
       return false;
     }
@@ -142,7 +146,12 @@ class StreamingProcessor implements LDStreamProcessor {
           }
           processJson(dataJson);
         } else {
-          this.errorHandler?.(new LDStreamingError('Unexpected payload from event stream'));
+          this.errorHandler?.(
+            new LDStreamingError(
+              DataSourceErrorKind.Unknown,
+              'Unexpected payload from event stream',
+            ),
+          );
         }
       });
     });

packages/shared/common/src/internal/stream/index.ts

@@ -1,5 +1,3 @@
 import StreamingProcessor from './StreamingProcessor';
-import type { StreamingErrorHandler } from './types';
 
 export { StreamingProcessor };
-export type { StreamingErrorHandler };

packages/shared/mocks/src/streamingProcessor.ts

@@ -1,11 +1,6 @@
-import type {
-  ClientContext,
-  EventName,
-  internal,
-  LDHeaders,
-  LDStreamingError,
-  ProcessStreamResponse,
-} from '@common';
+import type { ClientContext, EventName, internal, LDHeaders, ProcessStreamResponse } from '@common';
+
+type LDStreamingError = internal.LDStreamingError;
 
 export const MockStreamingProcessor = jest.fn();
 

packages/shared/sdk-client/__tests__/LDClientImpl.storage.test.ts

@@ -87,11 +87,8 @@ describe('sdk-client storage', () => {
 
     expect(mockPlatform.storage.get).toHaveBeenCalledWith(flagStorageKey);
 
-    // 'change' should not have been emitted
-    expect(emitter.emit).toHaveBeenCalledTimes(2);
-    expect(emitter.emit).toHaveBeenNthCalledWith(1, 'change', context, defaultFlagKeys);
-    expect(emitter.emit).toHaveBeenNthCalledWith(
-      2,
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, defaultFlagKeys);
+    expect(emitter.emit).toHaveBeenCalledWith(
       'error',
       context,
       expect.objectContaining({ message: 'test-error' }),
@@ -140,15 +137,12 @@ describe('sdk-client storage', () => {
     );
 
     // 'change' should not have been emitted
-    expect(emitter.emit).toHaveBeenCalledTimes(2);
-    expect(emitter.emit).toHaveBeenNthCalledWith(
-      1,
+    expect(emitter.emit).toHaveBeenCalledWith(
       'change',
       expect.objectContaining(toMulti(context)),
       defaultFlagKeys,
     );
-    expect(emitter.emit).toHaveBeenNthCalledWith(
-      2,
+    expect(emitter.emit).toHaveBeenCalledWith(
       'error',
       expect.objectContaining(toMulti(context)),
       expect.objectContaining({ message: 'test-error' }),
@@ -175,15 +169,17 @@ describe('sdk-client storage', () => {
 
     // @ts-ignore
     emitter = ldc.emitter;
-    jest.spyOn(emitter as LDEmitter, 'emit');
+    const spy = jest.spyOn(emitter as LDEmitter, 'emit');
 
     // expect emission
     await ldc.identify(context);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, defaultFlagKeys);
 
-    // expit no emission
+    // clear the spy so we can tell if change was invoked again
+    spy.mockClear();
+    // expect no emission
     await ldc.identify(context);
-
-    expect(emitter.emit).toHaveBeenCalledTimes(1);
+    expect(emitter.emit).not.toHaveBeenCalledWith('change', context, defaultFlagKeys);
   });
 
   test('no storage, cold start from streaming', async () => {
@@ -256,8 +252,8 @@ describe('sdk-client storage', () => {
       JSON.stringify(putResponse),
     );
 
-    expect(emitter.emit).toHaveBeenNthCalledWith(1, 'change', context, defaultFlagKeys);
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, defaultFlagKeys);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['dev-test-flag']);
   });
 
   test('syncing storage when a flag is added', async () => {
@@ -296,7 +292,7 @@ describe('sdk-client storage', () => {
       flagStorageKey,
       JSON.stringify(putResponse),
     );
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['another-dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['another-dev-test-flag']);
   });
 
   test('syncing storage when a flag is updated', async () => {
@@ -319,7 +315,7 @@ describe('sdk-client storage', () => {
     await jest.runAllTimersAsync();
 
     expect(ldc.allFlags()).toMatchObject({ 'dev-test-flag': false });
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['dev-test-flag']);
   });
 
   test('syncing storage on multiple flag operations', async () => {
@@ -347,7 +343,7 @@ describe('sdk-client storage', () => {
 
     expect(ldc.allFlags()).toMatchObject({ 'dev-test-flag': false, 'another-dev-test-flag': true });
     expect(ldc.allFlags()).not.toHaveProperty('moonshot-demo');
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, [
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, [
       'moonshot-demo',
       'dev-test-flag',
       'another-dev-test-flag',
@@ -380,8 +376,7 @@ describe('sdk-client storage', () => {
     );
 
     // we expect one change from the local storage init, but no further change from the PUT
-    expect(emitter.emit).toHaveBeenCalledTimes(1);
-    expect(emitter.emit).toHaveBeenNthCalledWith(1, 'change', context, defaultFlagKeys);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, defaultFlagKeys);
 
     // this is defaultPutResponse
     expect(ldc.allFlags()).toEqual({
@@ -423,7 +418,7 @@ describe('sdk-client storage', () => {
 
     // both previous and current are true but inExperiment has changed
     // so a change event should be emitted
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['dev-test-flag']);
   });
 
   test('patch should emit change event', async () => {
@@ -452,8 +447,7 @@ describe('sdk-client storage', () => {
     expect(ldc.allFlags()).toMatchObject({ 'dev-test-flag': false });
     expect(mockPlatform.storage.set).toHaveBeenCalledTimes(4);
     expect(flagsInStorage['dev-test-flag'].version).toEqual(patchResponse.version);
-    expect(emitter.emit).toHaveBeenCalledTimes(2);
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['dev-test-flag']);
   });
 
   test('patch should add new flags', async () => {
@@ -484,8 +478,7 @@ describe('sdk-client storage', () => {
       expect.stringContaining(JSON.stringify(patchResponse)),
     );
     expect(flagsInStorage).toHaveProperty('another-dev-test-flag');
-    expect(emitter.emit).toHaveBeenCalledTimes(2);
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['another-dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['another-dev-test-flag']);
   });
 
   test('patch should ignore older version', async () => {
@@ -557,8 +550,7 @@ describe('sdk-client storage', () => {
       expect.stringContaining('dev-test-flag'),
     );
     expect(flagsInStorage['dev-test-flag']).toMatchObject({ ...deleteResponse, deleted: true });
-    expect(emitter.emit).toHaveBeenCalledTimes(2);
-    expect(emitter.emit).toHaveBeenNthCalledWith(2, 'change', context, ['dev-test-flag']);
+    expect(emitter.emit).toHaveBeenCalledWith('change', context, ['dev-test-flag']);
   });
 
   test('delete should not delete equal version', async () => {