refactor: keep framework metadata internal

Remove the public client metadata options overloads and restore the original getClient signatures. Framework SDKs now mark SDK-owned client instances locally so framework metadata still flows into client and hook metadata without a public API change.

Signed-off-by: Jonathan Norris <jonathan.norris@dynatrace.com>

Author: jonathannorris

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

@@ -132,7 +132,7 @@ export abstract class FeatureFlagDirective<T extends FlagValue> implements OnIni
     if (this._client) {
       this.disposeClient(this._client);
     }
-    this._client = OpenFeature.getClient(this._featureFlagDomain, { framework: 'angular' });
+    this._client = setAngularFrameworkMetadata(OpenFeature.getClient(this._featureFlagDomain));
 
     const baseHandler = () => {
       const result = this.getFlagDetails(this._featureFlagKey, this._featureFlagDefault);
@@ -230,6 +230,15 @@ export abstract class FeatureFlagDirective<T extends FlagValue> implements OnIni
   }
 }
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'angular') => Client;
+};
+
+function setAngularFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('angular');
+  return client;
+}
+
 /**
  * A structural directive that conditionally includes a template based on the evaluation
  * of a boolean feature flag.

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

@@ -217,7 +217,7 @@ export class FeatureFlagService {
     domain: string | undefined,
     options?: AngularFlagEvaluationOptions,
   ): Observable<EvaluationDetails<T>> {
-    const client = OpenFeature.getClient(domain, { framework: 'angular' });
+    const client = setAngularFrameworkMetadata(OpenFeature.getClient(domain));
 
     return new Observable<EvaluationDetails<T>>((subscriber) => {
       let currentResult: EvaluationDetails<T> | undefined = undefined;
@@ -266,3 +266,12 @@ export class FeatureFlagService {
     });
   }
 }
+
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'angular') => Client;
+};
+
+function setAngularFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('angular');
+  return client;
+}

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

@@ -22,6 +22,10 @@ import { APP_INTERCEPTOR } from '@nestjs/core';
 import { EvaluationContextInterceptor } from './evaluation-context-interceptor';
 import { ShutdownService } from './shutdown.service';
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'nest') => Client;
+};
+
 /**
  * OpenFeatureModule is a NestJS wrapper for OpenFeature Server-SDK.
  */
@@ -45,7 +49,7 @@ export class OpenFeatureModule {
     const clientValueProviders: NestFactoryProvider<Client>[] = [
       {
         provide: getOpenFeatureClientToken(),
-        useFactory: () => OpenFeature.getClient(undefined, { framework: 'nest' }),
+        useFactory: () => setNestFrameworkMetadata(OpenFeature.getClient()),
       },
     ];
 
@@ -58,7 +62,7 @@ export class OpenFeatureModule {
         OpenFeature.setProvider(domain, provider);
         clientValueProviders.push({
           provide: getOpenFeatureClientToken(domain),
-          useFactory: () => OpenFeature.getClient(domain, { framework: 'nest' }),
+          useFactory: () => setNestFrameworkMetadata(OpenFeature.getClient(domain)),
         });
       });
     }
@@ -155,3 +159,8 @@ export interface OpenFeatureModuleOptions {
 export function getOpenFeatureClientToken(domain?: string): string {
   return domain ? `OpenFeatureClient_${domain}` : 'OpenFeatureClient_default';
 }
+
+function setNestFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('nest');
+  return client;
+}

packages/nest/src/utils.ts

@@ -1,12 +1,21 @@
 import type { Client, EvaluationContext } from '@openfeature/server-sdk';
 import { OpenFeature } from '@openfeature/server-sdk';
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'nest') => Client;
+};
+
 /**
  * Returns a domain scoped or the default OpenFeature client with the given context.
  * @param {string} domain The domain of the OpenFeature client.
  * @param {EvaluationContext} context The evaluation context of the client.
  * @returns {Client} The OpenFeature client.
  */
 export function getClientForEvaluation(domain?: string, context?: EvaluationContext) {
-  return OpenFeature.getClient(domain, { framework: 'nest' }, context);
+  return setNestFrameworkMetadata(domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context));
+}
+
+function setNestFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('nest');
+  return client;
 }

packages/react/src/provider/provider.tsx

@@ -41,7 +41,7 @@ export function OpenFeatureProvider({ client, domain, children, ...options }: Pr
       return setReactFrameworkMetadata(client);
     }
 
-    return OpenFeature.getClient(domain, { framework: 'react' });
+    return setReactFrameworkMetadata(OpenFeature.getClient(domain));
   }, [client, domain]);
 
   return <Context.Provider value={{ client: stableClient, options }}>{children}</Context.Provider>;

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

@@ -40,7 +40,6 @@ type OpenFeatureClientOptions = {
   name?: string;
   domain?: string;
   version?: string;
-  framework?: ClientFramework;
 };
 
 /**
@@ -68,7 +67,6 @@ export class OpenFeatureClient implements Client {
     context: EvaluationContext = {},
   ) {
     this._context = context;
-    this._framework = options.framework;
   }
 
   get metadata(): ClientMetadata {
@@ -84,6 +82,20 @@ export class OpenFeatureClient implements Client {
     };
   }
 
+  /**
+   * Sets framework metadata on an existing SDK-owned client instance.
+   *
+   * This is used by framework wrappers that must preserve a pre-created client
+   * instance instead of constructing a new framework-aware client.
+   * @param {ClientFramework} framework framework metadata to expose
+   * @returns {this} the updated client
+   * @internal
+   */
+  setFrameworkMetadata(framework: ClientFramework): this {
+    this._framework = framework;
+    return this;
+  }
+
   get providerStatus(): ProviderStatus {
     return this.providerStatusAccessor();
   }

packages/server/src/open-feature.ts

@@ -1,10 +1,4 @@
-import type {
-  ClientFramework,
-  ClientMetadataOptions,
-  EvaluationContext,
-  ManageContext,
-  ServerProviderStatus,
-} from '@openfeature/core';
+import type { EvaluationContext, ManageContext, ServerProviderStatus } from '@openfeature/core';
 import { OpenFeatureCommonAPI, ProviderWrapper, objectOrUndefined, stringOrUndefined } from '@openfeature/core';
 import type { Client } from './client';
 import { OpenFeatureClient } from './client/internal/open-feature-client';
@@ -187,19 +181,6 @@ export class OpenFeatureAPI
    * @returns {Client} OpenFeature Client
    */
   getClient(domain: string, context?: EvaluationContext): Client;
-  /**
-   * A factory function for creating new domain scoped OpenFeature clients.
-   * Clients can contain their own state (e.g. logger, hook, context).
-   * Multiple clients can be used to segment feature flag configuration.
-   *
-   * If there is already a provider bound to this domain via {@link this.setProvider setProvider}, this provider will be used.
-   * Otherwise, the default provider is used until a provider is assigned to that domain.
-   * @param {string} domain An identifier which logically binds clients with providers
-   * @param {ClientMetadataOptions} options Client metadata options
-   * @param {EvaluationContext} context Evaluation context that should be set on the client to used during flag evaluations
-   * @returns {Client} OpenFeature Client
-   */
-  getClient(domain: string | undefined, options: ClientMetadataOptions, context?: EvaluationContext): Client;
   /**
    * A factory function for creating new domain scoped OpenFeature clients.
    * Clients can contain their own state (e.g. logger, hook, context).
@@ -215,28 +196,20 @@ export class OpenFeatureAPI
   getClient(domain: string, version: string, context?: EvaluationContext): Client;
   getClient(
     domainOrContext?: string | EvaluationContext,
-    versionOrOptionsOrContext?: string | ClientMetadataOptions | EvaluationContext,
+    versionOrContext?: string | EvaluationContext,
     contextOrUndefined?: EvaluationContext,
   ): Client {
     const domain = stringOrUndefined(domainOrContext);
-    const options = clientMetadataOptionsOrUndefined(versionOrOptionsOrContext);
-    const version = stringOrUndefined(versionOrOptionsOrContext) ?? options?.version;
-    const context = domain
-      ? (objectOrUndefined<EvaluationContext>(options ? contextOrUndefined : versionOrOptionsOrContext) ??
-        objectOrUndefined<EvaluationContext>(contextOrUndefined))
-      : objectOrUndefined<EvaluationContext>(
-          domainOrContext ?? (options ? contextOrUndefined : versionOrOptionsOrContext),
-        );
+    const version = stringOrUndefined(versionOrContext);
+    const context =
+      objectOrUndefined<EvaluationContext>(domainOrContext) ??
+      objectOrUndefined<EvaluationContext>(versionOrContext) ??
+      objectOrUndefined<EvaluationContext>(contextOrUndefined);
 
-    return this._createClient(domain, version, context, options?.framework);
+    return this._createClient(domain, version, context);
   }
 
-  private _createClient(
-    domain?: string,
-    version?: string,
-    context: EvaluationContext = {},
-    framework?: ClientFramework,
-  ): Client {
+  private _createClient(domain?: string, version?: string, context: EvaluationContext = {}): Client {
     return new OpenFeatureClient(
       () => this.getProviderForClient(domain),
       () => this.getProviderStatus(domain),
@@ -245,7 +218,7 @@ export class OpenFeatureAPI
       () => this.getHooks(),
       () => this.getTransactionContext(),
       () => this._logger,
-      { domain, version, framework },
+      { domain, version },
       context,
     );
   }
@@ -297,13 +270,3 @@ export class OpenFeatureAPI
  * @returns {OpenFeatureAPI} OpenFeature API
  */
 export const OpenFeature = OpenFeatureAPI.getInstance();
-
-function clientMetadataOptionsOrUndefined(
-  value: string | ClientMetadataOptions | EvaluationContext | undefined,
-): ClientMetadataOptions | undefined {
-  if (typeof value === 'object' && value && ('version' in value || 'framework' in value)) {
-    return value as ClientMetadataOptions;
-  }
-
-  return undefined;
-}

packages/server/test/open-feature.spec.ts

@@ -195,23 +195,12 @@ describe('OpenFeature', () => {
       const contextOnly = { targetingKey: 'context-only' };
       const domainContext = { targetingKey: 'domain-context' };
       const versionContext = { targetingKey: 'version-context' };
-      const metadataContext = { targetingKey: 'metadata-context' };
 
       const defaultClient = OpenFeature.getClient();
       const contextClient = OpenFeature.getClient(contextOnly);
       const domainClient = OpenFeature.getClient('domain-only');
       const domainContextClient = OpenFeature.getClient('domain-context', domainContext);
       const legacyVersionClient = OpenFeature.getClient('legacy-version', '1.2.3', versionContext);
-      const defaultMetadataClient = OpenFeature.getClient(
-        undefined,
-        { version: '2.0.0', framework: 'nest' },
-        metadataContext,
-      );
-      const domainMetadataClient = OpenFeature.getClient(
-        'options-domain',
-        { version: '3.0.0', framework: 'nest' },
-        metadataContext,
-      );
 
       expect(defaultClient.metadata).toMatchObject({
         sdk: 'js-server',
@@ -242,21 +231,6 @@ describe('OpenFeature', () => {
         paradigm: 'server',
       });
       expect(legacyVersionClient.getContext()).toEqual(versionContext);
-      expect(defaultMetadataClient.metadata).toMatchObject({
-        version: '2.0.0',
-        sdk: 'js-server',
-        paradigm: 'server',
-        framework: 'nest',
-      });
-      expect(defaultMetadataClient.getContext()).toEqual(metadataContext);
-      expect(domainMetadataClient.metadata).toMatchObject({
-        domain: 'options-domain',
-        version: '3.0.0',
-        sdk: 'js-server',
-        paradigm: 'server',
-        framework: 'nest',
-      });
-      expect(domainMetadataClient.getContext()).toEqual(metadataContext);
     });
   });
 

packages/shared/src/client/client.ts

@@ -4,11 +4,6 @@ import type { Paradigm } from '../types/paradigm';
 export type ClientSdk = 'js-web' | 'js-server';
 export type ClientFramework = 'react' | 'angular' | 'nest';
 
-export interface ClientMetadataOptions {
-  readonly version?: string;
-  readonly framework?: ClientFramework;
-}
-
 export interface ClientMetadata {
   /**
    * @deprecated alias of "domain", use domain instead

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

@@ -40,7 +40,6 @@ type OpenFeatureClientOptions = {
   name?: string;
   domain?: string;
   version?: string;
-  framework?: ClientFramework;
 };
 
 /**
@@ -63,9 +62,7 @@ export class OpenFeatureClient implements Client {
     private readonly apiHooksAccessor: () => Hook[],
     private readonly globalLogger: () => Logger,
     private readonly options: OpenFeatureClientOptions,
-  ) {
-    this._framework = options.framework;
-  }
+  ) {}
 
   get metadata(): ClientMetadata {
     return {