feat: expose js sdk identity on client metadata

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,
@@ -132,7 +133,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,26 @@ 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: 'web',
+          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,45 @@ 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: 'server',
+        framework: 'nest',
+      });
+      expect(scopedClient.metadata).toMatchObject({
+        sdk: '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: '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,12 @@ 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: 'web',
+          framework: 'react',
+        });
       });
     });
 
@@ -81,6 +87,8 @@ describe('OpenFeatureProvider', () => {
         const { result } = renderHook(() => useOpenFeatureClient(), { wrapper });
 
         expect(result.current.metadata.domain).toEqual(DOMAIN);
+        expect(result.current.metadata.sdk).toEqual('web');
+        expect(result.current.metadata.framework).toEqual('react');
       });
 
       it('should return a stable client across renders', () => {
@@ -96,6 +104,45 @@ 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: 'web',
+              framework: 'react',
+            }),
+          }),
+          undefined,
+        );
+      });
     });
   });
 

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

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

packages/server/test/client.spec.ts

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

packages/shared/src/client/client.ts

@@ -7,5 +7,7 @@ export interface ClientMetadata {
   readonly name?: string;
   readonly domain?: string;
   readonly version?: string;
+  readonly sdk?: 'web' | 'server';
+  readonly framework?: 'react' | 'angular' | 'nest';
   readonly providerMetadata: ProviderMetadata;
 }

packages/shared/src/client/framework-metadata.ts

@@ -0,0 +1,35 @@
+import type { ClientMetadata } from './client';
+
+/**
+ * Wraps a client so framework metadata is visible through `metadata` and `this.metadata`.
+ * @template T
+ * @param {T} client client to wrap
+ * @param {NonNullable<ClientMetadata['framework']>} framework framework metadata to expose
+ * @returns {T} framework-aware client proxy
+ */
+export function withFrameworkMetadata<T extends object>(
+  client: T,
+  framework: NonNullable<ClientMetadata['framework']>,
+): T {
+  return new Proxy(client, {
+    get(target, property, receiver) {
+      if (property === 'metadata') {
+        return {
+          ...(Reflect.get(target, property, receiver) ?? {}),
+          framework,
+        };
+      }
+
+      const value = Reflect.get(target, property, receiver);
+
+      if (typeof value !== 'function') {
+        return value;
+      }
+
+      return (...args: unknown[]) => {
+        const result = value.apply(receiver, args);
+        return result === target ? receiver : result;
+      };
+    },
+  });
+}

packages/shared/src/client/index.ts

@@ -1 +1,2 @@
 export * from './client';
+export * from './framework-metadata';

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

@@ -68,6 +68,7 @@ export class OpenFeatureClient implements Client {
       name: this.options.domain ?? this.options.name,
       domain: this.options.domain ?? this.options.name,
       version: this.options.version,
+      sdk: 'web',
       providerMetadata: this.providerAccessor().metadata,
     };
   }

packages/web/test/client.spec.ts

@@ -181,6 +181,10 @@ describe('OpenFeatureClient', () => {
     it('should have metadata accessor with domain', () => {
       expect(client.metadata.domain).toEqual(domain);
     });
+
+    it('should expose the web sdk family in metadata', () => {
+      expect(client.metadata.sdk).toEqual('web');
+    });
   });
 
   describe('Requirement 1.3.1, 1.3.2.1', () => {