ldAdapter() » ldAdapter.variation() (#94)

* expose ldClient on default ldAdapter

* change API

* adapt README

* change to type import

* fix path

Author: dferber90

.changeset/chilly-bags-agree.md

@@ -0,0 +1,5 @@
+---
+'@flags-sdk/launchdarkly': minor
+---
+
+change API from ldAdapter() to ldAdapter.variation()

.changeset/smooth-turkeys-protect.md

@@ -0,0 +1,5 @@
+---
+'@flags-sdk/launchdarkly': patch
+---
+
+expose ldClient on default ldAdapter

packages/adapter-launchdarkly/README.md

@@ -44,7 +44,7 @@ const identify = dedupe(async (): Promise<LDContext> => {
 export const showBanner = flag<boolean, LDContext>({
   key: 'show-banner',
   identify,
-  adapter: ldAdapter(),
+  adapter: ldAdapter.variation(),
 });
 ```
 

packages/adapter-launchdarkly/src/index.test.ts

@@ -0,0 +1,70 @@
+import type { ReadonlyHeaders, ReadonlyRequestCookies } from 'flags';
+import { expect, it, describe, vi, beforeAll } from 'vitest';
+import { ldAdapter, type LDContext } from '.';
+
+const ldClientMock = {
+  waitForInitialization: vi.fn(),
+  variation: vi.fn(),
+};
+
+vi.mock('@launchdarkly/vercel-server-sdk', () => ({
+  init: vi.fn(() => ldClientMock),
+}));
+
+vi.mock('@vercel/edge-config', () => ({
+  createClient: vi.fn(),
+}));
+
+describe('ldAdapter', () => {
+  it('should variation should be a function', () => {
+    expect(ldAdapter.variation).toBeInstanceOf(Function);
+  });
+
+  describe('with a missing environment', () => {
+    it('should throw an error', () => {
+      expect(() => ldAdapter.variation()).toThrowError(
+        'LaunchDarkly Adapter: Missing EDGE_CONFIG environment variable',
+      );
+    });
+  });
+
+  describe('with an environment', () => {
+    beforeAll(() => {
+      process.env.LAUNCHDARKLY_PROJECT_SLUG = 'test-project';
+      process.env.LAUNCHDARKLY_CLIENT_SIDE_ID = 'test-client-side-id';
+      process.env.EDGE_CONFIG = 'https://edge-config.com/test-edge-config';
+    });
+
+    it('should expose the ldClient', () => {
+      expect(ldAdapter).toHaveProperty('ldClient');
+    });
+
+    describe('variation', () => {
+      it('should return the origin', () => {
+        const v = ldAdapter.variation();
+        expect(typeof v.origin).toEqual('function');
+
+        if (typeof v.origin !== 'function')
+          throw new Error('origin is not a function');
+
+        expect(v.origin?.('test-flag')).toEqual(
+          'https://app.launchdarkly.com/projects/test-project/flags/test-flag/',
+        );
+      });
+      it('should decide', async () => {
+        ldClientMock.variation.mockReturnValue(true);
+
+        const valuePromise = ldAdapter.variation().decide({
+          key: 'test-flag',
+          headers: {} as ReadonlyHeaders,
+          cookies: {} as ReadonlyRequestCookies,
+          entities: {} as LDContext,
+          defaultValue: false,
+        });
+
+        await expect(valuePromise).resolves.toEqual(true);
+        expect(ldClientMock.variation).toHaveBeenCalled();
+      });
+    });
+  });
+});

packages/adapter-launchdarkly/src/index.ts

@@ -13,6 +13,14 @@ interface AdapterOptions<ValueType> {
   defaultValue?: ValueType;
 }
 
+type AdapterResponse = {
+  variation: <ValueType>(
+    options?: AdapterOptions<ValueType>,
+  ) => Adapter<ValueType, LDContext>;
+  /** The LaunchDarkly client instance used by the adapter. */
+  ldClient: LDClient;
+};
+
 let defaultLaunchDarklyAdapter:
   | ReturnType<typeof createLaunchDarklyAdapter>
   | undefined;
@@ -35,23 +43,19 @@ export function createLaunchDarklyAdapter({
   projectSlug: string;
   clientSideId: string;
   edgeConfigConnectionString: string;
-}): {
-  <ValueType>(
-    options?: AdapterOptions<ValueType>,
-  ): Adapter<ValueType, LDContext>;
-  /** The LaunchDarkly client instance used by the adapter. */
-  ldClient: LDClient;
-} {
+}): AdapterResponse {
   const edgeConfigClient = createClient(edgeConfigConnectionString);
   const ldClient = init(clientSideId, edgeConfigClient);
 
-  const launchDarklyAdapter = function launchDarklyAdapter<ValueType>(
+  function origin(key: string) {
+    return `https://app.launchdarkly.com/projects/${projectSlug}/flags/${key}/`;
+  }
+
+  function variation<ValueType>(
     options: AdapterOptions<ValueType> = {},
   ): Adapter<ValueType, LDContext> {
     return {
-      origin(key) {
-        return `https://app.launchdarkly.com/projects/${projectSlug}/flags/${key}/`;
-      },
+      origin,
       async decide({ key, entities }): Promise<ValueType> {
         await ldClient.waitForInitialization();
         return ldClient.variation(
@@ -61,16 +65,15 @@ export function createLaunchDarklyAdapter({
         ) as ValueType;
       },
     };
-  };
-
-  launchDarklyAdapter.ldClient = ldClient;
+  }
 
-  return launchDarklyAdapter;
+  return {
+    ldClient,
+    variation,
+  };
 }
 
-export function ldAdapter<ValueType>(
-  options?: AdapterOptions<ValueType>,
-): Adapter<ValueType, LDContext> {
+function getOrCreateDeaultAdapter() {
   if (!defaultLaunchDarklyAdapter) {
     const edgeConfigConnectionString = assertEnv('EDGE_CONFIG');
     const clientSideId = assertEnv('LAUNCHDARKLY_CLIENT_SIDE_ID');
@@ -83,9 +86,38 @@ export function ldAdapter<ValueType>(
     });
   }
 
-  return defaultLaunchDarklyAdapter(options);
+  return defaultLaunchDarklyAdapter;
 }
 
+/**
+ * The default LaunchDarkly adapter.
+ *
+ * This is a convenience object that pre-initializes the LaunchDarkly SDK and provides
+ * the adapter function for usage with the Flags SDK.
+ *
+ * This is the recommended way to use the LaunchDarkly adapter.
+ *
+ * ```ts
+ * // flags.ts
+ * import { flag } from 'flags/next';
+ * import { ldAdapter, type LDContext } from '@flags-sdk/launchdarkly';
+ *
+ * const flag = flag<boolean, LDContext>({
+ *   key: 'my-flag',
+ *   defaultValue: false,
+ *   identify: () => ({ key: "user-123" }),
+ *   adapter: ldAdapter.variation(),
+ * });
+ * ```
+ */
+export const ldAdapter: AdapterResponse = {
+  variation: (...args) => getOrCreateDeaultAdapter().variation(...args),
+  get ldClient() {
+    return getOrCreateDeaultAdapter().ldClient;
+  },
+};
+
+/**
 /**
  * This is the previous name for the LaunchDarkly adapter.
  *