implements getFeature pattern

Author: tiagoapolo

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { createFlagsmithAdapter } from '.';
+import { flagsmithAdapter } from '.';
 import flagsmith, { IFlagsmithFeature, IState } from 'flagsmith';
 
 // Mock the flagsmith module
@@ -14,26 +14,24 @@ vi.mock('flagsmith', () => ({
 describe('Flagsmith Adapter', () => {
   beforeEach(() => {
     vi.resetAllMocks();
+    process.env.FLAGSMITH_ENVIRONMENT_ID = 'test-key';
   });
 
   afterEach(() => {
     vi.mocked(flagsmith.init).mockClear();
+    delete process.env.FLAGSMITH_ENVIRONMENT_ID;
     vi.clearAllMocks();
   });
 
   it('should initialize the adapter', async () => {
-    const adapter = createFlagsmithAdapter({
-      environmentID: 'test-key',
-    });
+    const adapter = flagsmithAdapter.getFeature();
 
     expect(adapter).toBeDefined();
     expect(adapter.decide).toBeDefined();
   });
 
   it('should initialize Flagsmith client when deciding flag value', async () => {
-    const adapter = createFlagsmithAdapter<IFlagsmithFeature, any>({
-      environmentID: 'test-key',
-    });
+    const adapter = flagsmithAdapter.getFeature();
 
     // Mock getState to return a specific flag value
     const mockFlag: IFlagsmithFeature = {
@@ -57,16 +55,14 @@ describe('Flagsmith Adapter', () => {
     });
 
     expect(flagsmith.init).toHaveBeenCalledWith({
-      environmentID: 'test-key',
       fetch: expect.any(Function),
+      environmentID: process.env.FLAGSMITH_ENVIRONMENT_ID,
     });
     expect(value).toEqual(mockFlag);
   });
 
   it('should return default value when flag is not found', async () => {
-    const adapter = createFlagsmithAdapter<IFlagsmithFeature, any>({
-      environmentID: 'test-key',
-    });
+    const adapter = flagsmithAdapter.getFeature();
 
     // Mock getState to return empty flags
     vi.mocked(flagsmith.getState).mockReturnValue({
@@ -91,9 +87,7 @@ describe('Flagsmith Adapter', () => {
   });
 
   it('should reuse initialized Flagsmith client', async () => {
-    const adapter = createFlagsmithAdapter<IFlagsmithFeature, any>({
-      environmentID: 'test-key',
-    });
+    const adapter = flagsmithAdapter.getFeature();
 
     // Set Flagsmith as already initialized
     vi.mocked(flagsmith).initialised = true;
@@ -115,8 +109,7 @@ describe('Flagsmith Adapter', () => {
   });
 
   it('should handle additional Flagsmith configuration options', async () => {
-    const adapter = createFlagsmithAdapter<IFlagsmithFeature, any>({
-      environmentID: 'test-key',
+    const adapter = flagsmithAdapter.getFeature({
       api: 'https://custom-api.com',
       enableLogs: true,
     });
@@ -131,10 +124,63 @@ describe('Flagsmith Adapter', () => {
     });
 
     expect(flagsmith.init).toHaveBeenCalledWith({
-      environmentID: 'test-key',
       api: 'https://custom-api.com',
       enableLogs: true,
+      environmentID: process.env.FLAGSMITH_ENVIRONMENT_ID,
+      fetch: expect.any(Function),
+    });
+  });
+
+  it('should handle manually set environmentID', async () => {
+    const adapter = flagsmithAdapter.getFeature({
+      environmentID: 'custom-env-id',
+    });
+
+    vi.mocked(flagsmith).initialised = false;
+
+    await adapter.decide({
+      key: 'test-flag',
+      entities: undefined,
+      headers: {} as any,
+      cookies: {} as any,
+    });
+
+    expect(flagsmith.init).toHaveBeenCalledWith({
+      environmentID: 'custom-env-id',
+      fetch: expect.any(Function),
+    });
+  });
+
+  it('should retrieve the feature flag value using the decide method', async () => {
+    const mockFlag: IFlagsmithFeature = {
+      enabled: true,
+      value: 'mocked-value',
+    };
+
+    vi.mocked(flagsmith.getState).mockReturnValue({
+      flags: {
+        'my-feature': mockFlag,
+      },
+      api: 'https://api.flagsmith.com/api/v1/',
+    } as IState<string>);
+
+    // Mock Flagsmith as not initialized
+    vi.mocked(flagsmith).initialised = false;
+
+    const adapter = flagsmithAdapter.getFeature();
+
+    const myFeatureFlag = await adapter.decide({
+      key: 'my-feature',
+      defaultValue: { enabled: false, value: 'default-value' },
+      entities: undefined,
+      headers: {} as any,
+      cookies: {} as any,
+    });
+
+    expect(flagsmith.init).toHaveBeenCalledWith({
+      environmentID: process.env.FLAGSMITH_ENVIRONMENT_ID,
       fetch: expect.any(Function),
     });
+    expect(myFeatureFlag).toEqual(mockFlag);
   });
 });

packages/adapter-flagsmith/src/index.ts

@@ -1,13 +1,20 @@
 import type { Adapter } from 'flags';
 import flagsmith, { IFlagsmithFeature, IInitConfig } from 'flagsmith';
 
+type AdapterParams = {
+  key?: string;
+} & IInitConfig;
+
 export function createFlagsmithAdapter<
   ValueType extends IFlagsmithFeature,
   EntitiesType,
->(config: IInitConfig): Adapter<ValueType, EntitiesType> {
+>({
+  key: customKey,
+  ...configParams
+}: AdapterParams): Adapter<ValueType, EntitiesType> {
   async function initialize(config: IInitConfig) {
     if (flagsmith?.initialised) return;
-    await flagsmith.init({ fetch: global.fetch, ...config });
+    await flagsmith.init({ fetch: global.fetch, ...configParams });
   }
 
   return {
@@ -18,11 +25,30 @@ export function createFlagsmithAdapter<
       cookies,
       defaultValue,
     }): Promise<ValueType> {
-      await initialize(config);
+      await initialize(configParams);
       const state = flagsmith.getState();
-      const flag = state?.flags?.[key] ?? defaultValue;
-
+      const keyName = customKey || key;
+      const flag = state?.flags?.[keyName] ?? defaultValue;
       return flag as ValueType;
     },
   };
 }
+
+// Lazy default adapter
+export const flagsmithAdapter = {
+  getFeature: <ValueType extends IFlagsmithFeature>(params?: AdapterParams) => {
+    const environmentID = process.env.FLAGSMITH_ENVIRONMENT_ID;
+    if (!environmentID && params?.environmentID) {
+      throw new Error(
+        '@flags-sdk/flagsmith: FLAGSMITH_ENVIRONMENT_ID is not set',
+      );
+    }
+
+    const adapter = createFlagsmithAdapter<ValueType, unknown>({
+      environmentID,
+      ...params,
+    });
+
+    return adapter;
+  },
+};