feat: expose js sdk identity on client metadata

packages/angular/projects/angular-sdk/src/lib/feature-flag.directive.spec.ts

@@ -5,6 +5,7 @@ import { By } from '@angular/platform-browser';
 import { Client, ClientProviderEvents, FlagValue, InMemoryProvider, OpenFeature } from '@openfeature/web-sdk';
 import { TestingProvider } from '../test/test.utils';
 import { v4 } from 'uuid';
+import { vi } from 'vitest';
 import {
   BooleanFeatureFlagDirective,
   FeatureFlagDirectiveContext,
@@ -182,6 +183,15 @@ class TestComponent {
   protected readonly JSON = JSON;
 }
 
+@Component({
+  standalone: true,
+  imports: [BooleanFeatureFlagDirective],
+  template: `<div *booleanFeatureFlag="'test-flag'; default: true; domain: domain">Flag On</div>`,
+})
+class SingleDirectiveTestComponent {
+  @Input() domain: string;
+}
+
 describe('FeatureFlagDirectiveContext', () => {
   it('should initialize $implicit and evaluationDetails from EvaluationDetails', () => {
     const mockDetails = {
@@ -361,6 +371,42 @@ describe('FeatureFlagDirective', () => {
   });
 
   describe('complex case', () => {
+    it('should only initialize the client once when the domain is set before init', async () => {
+      const domain = v4();
+      const provider = new TestingProvider(
+        {
+          'test-flag': {
+            variants: { default: true },
+            defaultVariant: 'default',
+            disabled: false,
+          },
+        },
+        0,
+      );
+      const getClientSpy = vi.spyOn(OpenFeature, 'getClient');
+
+      try {
+        const fixture = TestBed.configureTestingModule({
+          imports: [
+            OpenFeatureModule.forRoot({
+              provider: new InMemoryProvider(),
+              domainBoundProviders: { [domain]: provider },
+            }),
+            SingleDirectiveTestComponent,
+          ],
+        }).createComponent(SingleDirectiveTestComponent);
+
+        fixture.componentRef.setInput('domain', domain);
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        expect(getClientSpy).toHaveBeenCalledTimes(1);
+        expect(getClientSpy).toHaveBeenCalledWith(domain);
+      } finally {
+        getClientSpy.mockRestore();
+      }
+    });
+
     it('should use initializing, then, else and reconciling in one go', async () => {
       const { fixture, provider, client, domain } = await createTestingModule({
         flagConfiguration: {

packages/angular/projects/angular-sdk/src/lib/feature-flag.directive.ts

@@ -10,6 +10,7 @@ import {
   ViewContainerRef,
   inject,
 } from '@angular/core';
+import { withFrameworkMetadata } from '@openfeature/core';
 import {
   BooleanFlagKey,
   Client,
@@ -114,7 +115,9 @@ export abstract class FeatureFlagDirective<T extends FlagValue> implements OnIni
   }
 
   ngOnInit(): void {
-    this.initClient();
+    if (!this._client) {
+      this.initClient();
+    }
   }
 
   ngOnChanges(): void {
@@ -132,7 +135,7 @@ export abstract class FeatureFlagDirective<T extends FlagValue> implements OnIni
     if (this._client) {
       this.disposeClient(this._client);
     }
-    this._client = OpenFeature.getClient(this._featureFlagDomain);
+    this._client = withFrameworkMetadata(OpenFeature.getClient(this._featureFlagDomain), 'angular');
 
     const baseHandler = () => {
       const result = this.getFlagDetails(this._featureFlagKey, this._featureFlagDefault);

packages/angular/projects/angular-sdk/src/lib/feature-flag.service.spec.ts

@@ -8,6 +8,7 @@ import { AsyncPipe } from '@angular/common';
 import { TestingProvider } from '../test/test.utils';
 import { OpenFeatureModule } from './open-feature.module';
 import { toSignal } from '@angular/core/rxjs-interop';
+import { vi } from 'vitest';
 
 const FLAG_KEY = 'thumbs';
 
@@ -114,6 +115,7 @@ describe('FeatureFlagService', () => {
 
   afterEach(async () => {
     await OpenFeature.close();
+    OpenFeature.clearHooks();
     await OpenFeature.setContext({});
     currentTestComponentFixture?.destroy();
     currentContextChangeDisabledComponentFixture?.destroy();
@@ -129,6 +131,27 @@ describe('FeatureFlagService', () => {
     expect(observableValue?.textContent).toBe('👍');
   });
 
+  it('should surface angular metadata in hook contexts', async () => {
+    const hook = { before: vi.fn() };
+
+    OpenFeature.addHooks(hook);
+    await createTestingModule();
+    service = TestBed.inject(FeatureFlagService);
+
+    await firstValueFrom(service.getBooleanDetails(FLAG_KEY, false));
+
+    expect(hook.before).toHaveBeenCalledWith(
+      expect.objectContaining({
+        clientMetadata: expect.objectContaining({
+          sdk: 'js-web',
+          paradigm: 'client',
+          framework: 'angular',
+        }),
+      }),
+      undefined,
+    );
+  });
+
   it('should render updated value after delay', async () => {
     const delay = 50;
     await createTestingModule({ providerInitDelay: delay });

packages/angular/projects/angular-sdk/src/lib/feature-flag.service.ts

@@ -1,3 +1,4 @@
+import { withFrameworkMetadata } from '@openfeature/core';
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import {
@@ -217,7 +218,7 @@ export class FeatureFlagService {
     domain: string | undefined,
     options?: AngularFlagEvaluationOptions,
   ): Observable<EvaluationDetails<T>> {
-    const client = domain ? OpenFeature.getClient(domain) : OpenFeature.getClient();
+    const client = withFrameworkMetadata(domain ? OpenFeature.getClient(domain) : OpenFeature.getClient(), 'angular');
 
     return new Observable<EvaluationDetails<T>>((subscriber) => {
       let currentResult: EvaluationDetails<T> | undefined = undefined;

packages/nest/src/open-feature.module.ts

@@ -15,6 +15,7 @@ import type {
   EventHandler,
   Logger,
 } from '@openfeature/server-sdk';
+import { withFrameworkMetadata } from '@openfeature/core';
 import { OpenFeature, AsyncLocalStorageTransactionContextPropagator } from '@openfeature/server-sdk';
 import type { ContextFactory } from './context-factory';
 import { ContextFactoryToken } from './context-factory';
@@ -45,7 +46,7 @@ export class OpenFeatureModule {
     const clientValueProviders: NestFactoryProvider<Client>[] = [
       {
         provide: getOpenFeatureClientToken(),
-        useFactory: () => OpenFeature.getClient(),
+        useFactory: () => withFrameworkMetadata(OpenFeature.getClient(), 'nest'),
       },
     ];
 
@@ -58,7 +59,7 @@ export class OpenFeatureModule {
         OpenFeature.setProvider(domain, provider);
         clientValueProviders.push({
           provide: getOpenFeatureClientToken(domain),
-          useFactory: () => OpenFeature.getClient(domain),
+          useFactory: () => withFrameworkMetadata(OpenFeature.getClient(domain), 'nest'),
         });
       });
     }

packages/nest/src/utils.ts

@@ -1,3 +1,4 @@
+import { withFrameworkMetadata } from '@openfeature/core';
 import type { Client, EvaluationContext } from '@openfeature/server-sdk';
 import { OpenFeature } from '@openfeature/server-sdk';
 
@@ -8,5 +9,8 @@ import { OpenFeature } from '@openfeature/server-sdk';
  * @returns {Client} The OpenFeature client.
  */
 export function getClientForEvaluation(domain?: string, context?: EvaluationContext) {
-  return domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context);
+  return withFrameworkMetadata(
+    domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context),
+    'nest',
+  );
 }

packages/nest/test/open-feature.module.spec.ts

@@ -3,7 +3,7 @@ import { Test } from '@nestjs/testing';
 import { getOpenFeatureClientToken, OpenFeatureModule, ServerProviderEvents } from '../src';
 import type { Client } from '@openfeature/server-sdk';
 import { OpenFeature } from '@openfeature/server-sdk';
-import { getOpenFeatureDefaultTestModule } from './fixtures';
+import { defaultProvider, getOpenFeatureDefaultTestModule } from './fixtures';
 
 describe('OpenFeatureModule', () => {
   let moduleRef: TestingModule;
@@ -49,6 +49,48 @@ describe('OpenFeatureModule', () => {
       expect(client).toBeDefined();
       expect(await client.getStringValue('testStringFlag', '')).toEqual('expected-string-value-scoped');
     });
+
+    it('should expose nest framework metadata on injected clients', () => {
+      const defaultClient = moduleRef.get<Client>(getOpenFeatureClientToken());
+      const scopedClient = moduleRef.get<Client>(getOpenFeatureClientToken('domainScopedClient'));
+
+      expect(defaultClient.metadata).toMatchObject({
+        sdk: 'js-server',
+        paradigm: 'server',
+        framework: 'nest',
+      });
+      expect(scopedClient.metadata).toMatchObject({
+        sdk: 'js-server',
+        paradigm: 'server',
+        framework: 'nest',
+      });
+    });
+
+    it('should surface nest metadata in hook contexts', async () => {
+      const hook = { before: jest.fn() };
+      const hookModuleRef = await Test.createTestingModule({
+        imports: [OpenFeatureModule.forRoot({ defaultProvider, hooks: [hook] })],
+      }).compile();
+
+      try {
+        const client = hookModuleRef.get<Client>(getOpenFeatureClientToken());
+        await client.getBooleanValue('testBooleanFlag', false);
+
+        expect(hook.before).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientMetadata: expect.objectContaining({
+              sdk: 'js-server',
+              paradigm: 'server',
+              framework: 'nest',
+            }),
+          }),
+          undefined,
+        );
+      } finally {
+        await hookModuleRef.close();
+        OpenFeature.clearHooks();
+      }
+    });
   });
 
   describe('handlers', () => {

packages/react/src/provider/provider.tsx

@@ -1,3 +1,4 @@
+import { withFrameworkMetadata } from '@openfeature/core';
 import type { Client } from '@openfeature/web-sdk';
 import { OpenFeature } from '@openfeature/web-sdk';
 import * as React from 'react';
@@ -32,7 +33,10 @@ type ProviderProps = {
  * @returns {OpenFeatureProvider} context provider
  */
 export function OpenFeatureProvider({ client, domain, children, ...options }: ProviderProps) {
-  const stableClient = React.useMemo(() => client || OpenFeature.getClient(domain), [client, domain]);
+  const stableClient = React.useMemo(
+    () => withFrameworkMetadata(client || OpenFeature.getClient(domain), 'react'),
+    [client, domain],
+  );
 
   return <Context.Provider value={{ client: stableClient, options }}>{children}</Context.Provider>;
 }

packages/react/test/provider.spec.tsx

@@ -53,13 +53,14 @@ describe('OpenFeatureProvider', () => {
 
   beforeEach(async () => {
     await OpenFeature.clearContexts();
+    OpenFeature.clearHooks();
   });
 
   describe('useOpenFeatureClient', () => {
     const DOMAIN = 'useOpenFeatureClient';
 
     describe('client specified', () => {
-      it('should return client from provider', () => {
+      it('should return a react-aware client from provider', () => {
         const client = OpenFeature.getClient(DOMAIN);
 
         const wrapper = ({ children }: Parameters<typeof OpenFeatureProvider>[0]) => (
@@ -68,7 +69,13 @@ describe('OpenFeatureProvider', () => {
 
         const { result } = renderHook(() => useOpenFeatureClient(), { wrapper });
 
-        expect(result.current).toEqual(client);
+        expect(result.current).not.toBe(client);
+        expect(result.current.metadata).toMatchObject({
+          domain: DOMAIN,
+          sdk: 'js-web',
+          paradigm: 'client',
+          framework: 'react',
+        });
       });
     });
 
@@ -81,6 +88,9 @@ describe('OpenFeatureProvider', () => {
         const { result } = renderHook(() => useOpenFeatureClient(), { wrapper });
 
         expect(result.current.metadata.domain).toEqual(DOMAIN);
+        expect(result.current.metadata.sdk).toEqual('js-web');
+        expect(result.current.metadata.paradigm).toEqual('client');
+        expect(result.current.metadata.framework).toEqual('react');
       });
 
       it('should return a stable client across renders', () => {
@@ -96,6 +106,46 @@ describe('OpenFeatureProvider', () => {
 
         expect(firstClient).toBe(secondClient);
       });
+
+      it('should surface react metadata in hook contexts', async () => {
+        const hook = { before: jest.fn() };
+
+        OpenFeature.setProvider(
+          DOMAIN,
+          new InMemoryProvider({
+            greeting: {
+              disabled: false,
+              variants: { default: 'hello' },
+              defaultVariant: 'default',
+            },
+          }),
+        );
+
+        const wrapper = ({ children }: Parameters<typeof OpenFeatureProvider>[0]) => (
+          <OpenFeatureProvider domain={DOMAIN}>{children}</OpenFeatureProvider>
+        );
+
+        const { result } = renderHook(
+          () =>
+            useStringFlagValue('greeting', 'fallback', {
+              hooks: [hook],
+            }),
+          { wrapper },
+        );
+
+        await waitFor(() => expect(result.current).toEqual('hello'));
+        expect(hook.before).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientMetadata: expect.objectContaining({
+              domain: DOMAIN,
+              sdk: 'js-web',
+              paradigm: 'client',
+              framework: 'react',
+            }),
+          }),
+          undefined,
+        );
+      });
     });
   });
 

packages/server/src/client/client.ts

@@ -1,4 +1,4 @@
-import type { ClientMetadata, EvaluationLifeCycle, Eventing, ManageContext, ManageLogger } from '@openfeature/core';
+import type { EvaluationLifeCycle, Eventing, ManageContext, ManageLogger, MetadataClient } from '@openfeature/core';
 import type { Features } from '../evaluation';
 import type { ProviderStatus } from '../provider';
 import type { ProviderEvents } from '../events';
@@ -11,8 +11,8 @@ export interface Client
     ManageContext<Client>,
     ManageLogger<Client>,
     Tracking,
-    Eventing<ProviderEvents> {
-  readonly metadata: ClientMetadata;
+    Eventing<ProviderEvents>,
+    MetadataClient {
   /**
    * Returns the status of the associated provider.
    */

packages/server/src/client/internal/open-feature-client.ts

@@ -73,6 +73,8 @@ export class OpenFeatureClient implements Client {
       name: this.options.domain ?? this.options.name,
       domain: this.options.domain ?? this.options.name,
       version: this.options.version,
+      sdk: 'js-server',
+      paradigm: 'server',
       providerMetadata: this.providerAccessor().metadata,
     };
   }

packages/server/test/client.spec.ts

@@ -184,6 +184,11 @@ describe('OpenFeatureClient', () => {
     it('should have metadata accessor with domain', () => {
       expect(client.metadata.domain).toEqual(domain);
     });
+
+    it('should expose sdk family and paradigm in metadata', () => {
+      expect(client.metadata.sdk).toEqual('js-server');
+      expect(client.metadata.paradigm).toEqual('server');
+    });
   });
 
   describe('Requirement 1.3.1, 1.3.2.1', () => {