@servicetitan/launchdarkly-service 39.2.0 → 40.0.0

package/src/tests/get-ld-client.test.ts

@@ -1,68 +1,54 @@
-import { initialize } from 'launchdarkly-js-client-sdk';
+import { createLDClient } from '../create-ld-client';
 import { getLDClient } from '../get-ld-client';
+import { getSDKVersion } from '../get-sdk-version';
+import { getVersionClient } from '../get-version-client';
+import { ClientConfig } from '../types';
 
-jest.mock('launchdarkly-js-client-sdk', () => ({
-    initialize: jest.fn(),
+jest.mock('../create-ld-client', () => ({
+    createLDClient: jest.fn(),
+}));
+jest.mock('../get-sdk-version', () => ({
+    getSDKVersion: jest.fn(),
+}));
+jest.mock('../get-version-client', () => ({
+    getVersionClient: jest.fn(),
 }));
 
 describe(`[launchdarkly-service] ${getLDClient.name}`, () => {
-    const mockClient: any = Symbol('mockClient');
-    const defaultOptions = { sendEventsOnlyForVariation: true };
-    let config: Parameters<typeof getLDClient>[0];
+    const client: any = Symbol('client');
+    const version = '3.9.5';
+    let config: ClientConfig;
 
     const subject = () => getLDClient(config);
 
     beforeEach(() => {
         jest.clearAllMocks();
-        jest.mocked(initialize).mockImplementation(() => mockClient);
+        jest.mocked(getSDKVersion).mockReturnValue(version);
+        jest.mocked(getVersionClient).mockReturnValue(client);
         config = { clientSideID: makeId(), context: { kind: 'multi' } };
     });
 
-    test('initializes client with the given context and default options', () => {
-        expect(subject()).toBe(mockClient);
-        expect(initialize).toHaveBeenCalledWith(
-            config.clientSideID,
-            config.context,
-            defaultOptions
-        );
-    });
-
-    describe('when given options', () => {
-        beforeEach(() => (config.options = { hash: 'foo' }));
-
-        test('passes options through alongside the defaults', () => {
-            subject();
+    test('requests it using the running SDK version, the config, and a client factory', () => {
+        subject();
 
-            expect(initialize).toHaveBeenCalledWith(config.clientSideID, config.context, {
-                ...defaultOptions,
-                ...config.options,
-            });
-        });
+        expect(getVersionClient).toHaveBeenCalledWith(version, config, createLDClient);
     });
 
-    describe('when given sendEventsOnlyForVariation', () => {
-        beforeEach(() => (config.options = { sendEventsOnlyForVariation: false }));
-
-        test('lets the caller override the default', () => {
-            subject();
-
-            expect(initialize).toHaveBeenCalledWith(config.clientSideID, config.context, {
-                sendEventsOnlyForVariation: false,
-            });
-        });
+    test('returns the client', () => {
+        expect(subject()).toBe(client);
     });
 
-    describe('when client already exists', () => {
-        const existingClient: any = Symbol('existingClient');
+    describe('when the running SDK version is unknown', () => {
+        beforeEach(() => jest.mocked(getSDKVersion).mockReturnValue(undefined));
 
-        beforeEach(() => {
-            jest.mocked(initialize).mockImplementationOnce(() => existingClient);
+        test('uses a syntactically valid semver as the version', () => {
             subject();
-        });
 
-        test('returns existing client', () => {
-            expect(subject()).toBe(existingClient);
-            expect(initialize).toHaveBeenCalledTimes(1);
+            expect(getVersionClient).toHaveBeenCalledWith(
+                expect.stringMatching(/^\d+\.\d+\.\d+-\S+$/),
+                config,
+                createLDClient
+            );
         });
     });
 });

package/src/tests/get-sdk-version.test.ts

@@ -0,0 +1,48 @@
+import { getSDKVersion } from '../get-sdk-version';
+
+let mockSdkVersion: string | undefined;
+let mockPackageJsonVersion: string | undefined;
+
+jest.mock('launchdarkly-js-client-sdk', () => ({
+    get version() {
+        return mockSdkVersion;
+    },
+}));
+jest.mock('launchdarkly-js-client-sdk/package.json', () => ({
+    get version() {
+        return mockPackageJsonVersion;
+    },
+}));
+
+describe(`[launchdarkly-service] ${getSDKVersion.name}`, () => {
+    beforeEach(() => {
+        mockSdkVersion = '3.9.5';
+        mockPackageJsonVersion = '3.9.6';
+    });
+
+    const subject = () => getSDKVersion();
+
+    test('returns the version exported by the running SDK', () => {
+        expect(subject()).toBe(mockSdkVersion);
+    });
+
+    describe('when the running SDK does not export a version', () => {
+        beforeEach(() => {
+            mockSdkVersion = undefined;
+        });
+
+        test('returns the version from package.json instead', () => {
+            expect(subject()).toBe(mockPackageJsonVersion);
+        });
+
+        describe('when package.json also has no version', () => {
+            beforeEach(() => {
+                mockPackageJsonVersion = undefined;
+            });
+
+            test('returns undefined', () => {
+                expect(subject()).toBeUndefined();
+            });
+        });
+    });
+});

package/src/tests/get-version-client.test.ts

@@ -0,0 +1,70 @@
+import { LDClient } from 'launchdarkly-js-client-sdk';
+import { getVersionClient } from '../get-version-client';
+import { ClientConfig } from '../types';
+
+describe(`[launchdarkly-service] ${getVersionClient.name}`, () => {
+    let version: string;
+    let config: ClientConfig;
+    let createClient: jest.Mock<LDClient, [ClientConfig]>;
+    let client: LDClient;
+
+    const subject = () => getVersionClient(version, config, createClient);
+
+    beforeEach(() => {
+        version = '3.9.5';
+        config = { clientSideID: makeId(), context: { kind: 'multi' } };
+        client = Symbol('client') as unknown as LDClient;
+        createClient = jest.fn().mockReturnValue(client);
+    });
+
+    test('returns the client created by createClient', () => {
+        expect(subject()).toBe(client);
+    });
+
+    test('creates the client using the given config', () => {
+        subject();
+
+        expect(createClient).toHaveBeenCalledWith(config);
+    });
+
+    describe('when a client already exists', () => {
+        const newClient = Symbol('newClient') as unknown as LDClient;
+
+        beforeEach(() => {
+            subject();
+            createClient.mockClear();
+            createClient.mockReturnValue(newClient);
+        });
+
+        test('returns the existing client', () => {
+            expect(subject()).toBe(client);
+            expect(createClient).not.toHaveBeenCalled();
+        });
+
+        function itCreatesNewClient() {
+            test('creates a new client', () => {
+                expect(subject()).toBe(newClient);
+            });
+        }
+
+        describe('when clientSideID differs', () => {
+            beforeEach(() => {
+                config = { ...config, clientSideID: makeId() };
+            });
+
+            itCreatesNewClient();
+        });
+
+        describe('when version differs', () => {
+            beforeEach(() => {
+                version = '3.5.0';
+            });
+
+            itCreatesNewClient();
+        });
+    });
+});
+
+function makeId() {
+    return Math.round(1e6 * Math.random()).toString(36);
+}

package/src/tests/ld-service-provider.test.tsx

@@ -3,6 +3,7 @@ import { render } from '@testing-library/react';
 import { LDOptions } from 'launchdarkly-js-client-sdk';
 import { ComponentProps, FC } from 'react';
 import { getLDClient } from '../get-ld-client';
+import { getVersionClient } from '../get-version-client';
 import { LDServiceProvider } from '../ld-service-provider';
 import { LD_SERVICE_TOKEN, LDApplication, LDService } from '../types';
 
@@ -38,7 +39,7 @@ describe(`[launchdarkly-service] ${LDServiceProvider.name}`, () => {
     test('provides LDService instance', () => {
         subject();
 
-        expect(providedLDService).toEqual({ getClient: getLDClient });
+        expect(providedLDService).toEqual({ getClient: getLDClient, getVersionClient });
     });
 
     test('provides no application', () => {

package/src/types.ts

@@ -13,6 +13,17 @@ export interface ClientConfig {
 
 export interface LDService {
     getClient: (config: ClientConfig) => LDClient;
+    /**
+     * Like `getClient`, but shares the client with any other caller using the same `version` and
+     * `clientSideID`, regardless of which side's SDK build constructed it. Callers supply
+     * `createClient` because the provider may not have the SDK version needed to build a client
+     * for a `version` it doesn't recognize.
+     */
+    getVersionClient?: (
+        version: string,
+        config: ClientConfig,
+        createClient: (config: ClientConfig) => LDClient
+    ) => LDClient;
     application?: LDApplication;
     options?: Omit<LDOptions, 'application'>;
 }