fix: resolve TypeScript errors in multi-provider with proper generic types

Signed-off-by: Jonathan Norris <[email protected]>

Author: jonathannorris

packages/server/src/provider/multi-provider/multi-provider.ts

@@ -13,10 +13,10 @@ import type {
   ProviderMetadata,
   ResolutionDetails,
   TrackingEventDetails,
-  BaseEvaluationStrategy,
   ProviderResolutionResult,
   ProviderEntryInput,
   RegisteredProvider,
+  BaseEvaluationStrategy,
 } from '@openfeature/core';
 import {
   DefaultLogger,
@@ -29,8 +29,10 @@ import {
   StatusTracker,
 } from '@openfeature/core';
 import type { Provider } from '../provider';
+import { ProviderStatus } from '../provider';
 import type { Hook } from '../../hooks';
 import { OpenFeatureEventEmitter } from '../../events/open-feature-event-emitter';
+import { ProviderEvents } from '../../events';
 import { HookExecutor } from './hook-executor';
 
 export class MultiProvider implements Provider {
@@ -43,15 +45,21 @@ export class MultiProvider implements Provider {
 
   metadata: ProviderMetadata;
 
-  providerEntries: RegisteredProvider[] = [];
-  private providerEntriesByName: Record<string, RegisteredProvider> = {};
+  providerEntries: RegisteredProvider<Provider>[] = [];
+  private providerEntriesByName: Record<string, RegisteredProvider<Provider>> = {};
 
   private hookExecutor: HookExecutor;
-  private statusTracker = new StatusTracker(this.events);
+  private statusTracker = new StatusTracker<
+    (typeof ProviderEvents)[keyof typeof ProviderEvents],
+    ProviderStatus,
+    Provider
+  >(this.events, ProviderStatus, ProviderEvents);
 
   constructor(
-    readonly constructorProviders: ProviderEntryInput[],
-    private readonly evaluationStrategy: BaseEvaluationStrategy = new FirstMatchStrategy(),
+    readonly constructorProviders: ProviderEntryInput<Provider>[],
+    private readonly evaluationStrategy: BaseEvaluationStrategy<ProviderStatus, Provider> = new FirstMatchStrategy(
+      ProviderStatus,
+    ),
     private readonly logger: Logger = new DefaultLogger(),
   ) {
     this.hookExecutor = new HookExecutor(this.logger);
@@ -68,7 +76,7 @@ export class MultiProvider implements Provider {
     };
   }
 
-  private registerProviders(constructorProviders: ProviderEntryInput[]) {
+  private registerProviders(constructorProviders: ProviderEntryInput<Provider>[]) {
     const providersByName: Record<string, Provider[]> = {};
 
     for (const constructorProvider of constructorProviders) {
@@ -155,7 +163,7 @@ export class MultiProvider implements Provider {
       throw new GeneralError('Hook context not available for evaluation');
     }
 
-    const tasks: Promise<[boolean, ProviderResolutionResult<T> | null]>[] = [];
+    const tasks: Promise<[boolean, ProviderResolutionResult<T, ProviderStatus, Provider> | null]>[] = [];
 
     for (const providerEntry of this.providerEntries) {
       const task = this.evaluateProviderEntry(
@@ -181,7 +189,7 @@ export class MultiProvider implements Provider {
     const results = await Promise.all(tasks);
     const resolutions = results
       .map(([, resolution]) => resolution)
-      .filter((r): r is ProviderResolutionResult<T> => Boolean(r));
+      .filter((r): r is ProviderResolutionResult<T, ProviderStatus, Provider> => Boolean(r));
 
     const finalResult = this.evaluationStrategy.determineFinalResult({ flagKey, flagType }, context, resolutions);
 
@@ -200,17 +208,17 @@ export class MultiProvider implements Provider {
     flagKey: string,
     flagType: FlagValueType,
     defaultValue: T,
-    providerEntry: RegisteredProvider,
+    providerEntry: RegisteredProvider<Provider>,
     hookContext: HookContext,
     hookHints: HookHints,
     context: EvaluationContext,
-  ): Promise<[boolean, ProviderResolutionResult<T> | null]> {
+  ): Promise<[boolean, ProviderResolutionResult<T, ProviderStatus, Provider> | null]> {
     let evaluationResult: ResolutionDetails<T> | undefined = undefined;
     const provider = providerEntry.provider;
     const strategyContext = {
       flagKey,
       flagType,
-      provider,
+      provider: provider as Provider,
       providerName: providerEntry.name,
       providerStatus: this.statusTracker.providerStatus(providerEntry.name),
     };
@@ -219,19 +227,19 @@ export class MultiProvider implements Provider {
       return [true, null];
     }
 
-    let resolution: ProviderResolutionResult<T>;
+    let resolution: ProviderResolutionResult<T, ProviderStatus, Provider>;
 
     try {
       evaluationResult = await this.evaluateProviderAndHooks(flagKey, defaultValue, provider, hookContext, hookHints);
       resolution = {
         details: evaluationResult,
-        provider: provider,
+        provider: provider as Provider,
         providerName: providerEntry.name,
       };
     } catch (error: unknown) {
       resolution = {
         thrownError: error,
-        provider: provider,
+        provider: provider as Provider,
         providerName: providerEntry.name,
       };
     }
@@ -322,7 +330,7 @@ export class MultiProvider implements Provider {
       }
 
       const strategyContext = {
-        provider: providerEntry.provider,
+        provider: providerEntry.provider as Provider,
         providerName: providerEntry.name,
         providerStatus: this.statusTracker.providerStatus(providerEntry.name),
       };

packages/shared/src/provider/multi-provider/errors.ts

@@ -34,9 +34,9 @@ export const constructAggregateError = (providerErrors: { error: unknown; provid
   );
 };
 
-export const throwAggregateErrorFromPromiseResults = (
+export const throwAggregateErrorFromPromiseResults = <TProvider>(
   result: PromiseSettledResult<unknown>[],
-  providerEntries: RegisteredProvider[],
+  providerEntries: RegisteredProvider<TProvider>[],
 ) => {
   const errors = result
     .map((r, i) => {

packages/shared/src/provider/multi-provider/status-tracker.ts

@@ -1,33 +1,39 @@
-import type { EventDetails, ProviderEventEmitter } from '../../events';
-import { AllProviderEvents } from '../../events';
-import { AllProviderStatus } from '../../provider';
+import type { EventDetails, ProviderEventEmitter, AnyProviderEvent } from '../../events';
 import type { RegisteredProvider } from './types';
 
 /**
  * Tracks each individual provider's status by listening to emitted events
  * Maintains an overall "status" for the multi provider which represents the "most critical" status out of all providers
  */
-export class StatusTracker {
-  private readonly providerStatuses: Record<string, AllProviderStatus> = {};
+export class StatusTracker<
+  TProviderEvents extends AnyProviderEvent,
+  TProviderStatus,
+  TProvider extends { events?: ProviderEventEmitter<TProviderEvents> },
+> {
+  private readonly providerStatuses: Record<string, TProviderStatus> = {};
 
-  constructor(private events: ProviderEventEmitter<AllProviderEvents>) {}
+  constructor(
+    private events: ProviderEventEmitter<TProviderEvents>,
+    private statusEnum: Record<string, TProviderStatus>,
+    private eventEnum: Record<string, TProviderEvents>,
+  ) {}
 
-  wrapEventHandler(providerEntry: RegisteredProvider) {
+  wrapEventHandler(providerEntry: RegisteredProvider<TProvider>) {
     const provider = providerEntry.provider;
-    provider.events?.addHandler(AllProviderEvents.Error, (details?: EventDetails) => {
-      this.changeProviderStatus(providerEntry.name, AllProviderStatus.ERROR, details);
+    provider.events?.addHandler(this.eventEnum.Error as TProviderEvents, (details?: EventDetails) => {
+      this.changeProviderStatus(providerEntry.name, this.statusEnum.ERROR, details);
     });
 
-    provider.events?.addHandler(AllProviderEvents.Stale, (details?: EventDetails) => {
-      this.changeProviderStatus(providerEntry.name, AllProviderStatus.STALE, details);
+    provider.events?.addHandler(this.eventEnum.Stale as TProviderEvents, (details?: EventDetails) => {
+      this.changeProviderStatus(providerEntry.name, this.statusEnum.STALE, details);
     });
 
-    provider.events?.addHandler(AllProviderEvents.ConfigurationChanged, (details?: EventDetails) => {
-      this.events.emit(AllProviderEvents.ConfigurationChanged, details);
+    provider.events?.addHandler(this.eventEnum.ConfigurationChanged as TProviderEvents, (details?: EventDetails) => {
+      this.events.emit(this.eventEnum.ConfigurationChanged as TProviderEvents, details);
     });
 
-    provider.events?.addHandler(AllProviderEvents.Ready, (details?: EventDetails) => {
-      this.changeProviderStatus(providerEntry.name, AllProviderStatus.READY, details);
+    provider.events?.addHandler(this.eventEnum.Ready as TProviderEvents, (details?: EventDetails) => {
+      this.changeProviderStatus(providerEntry.name, this.statusEnum.READY, details);
     });
   }
 
@@ -37,29 +43,29 @@ export class StatusTracker {
 
   private getStatusFromProviderStatuses() {
     const statuses = Object.values(this.providerStatuses);
-    if (statuses.includes(AllProviderStatus.FATAL)) {
-      return AllProviderStatus.FATAL;
-    } else if (statuses.includes(AllProviderStatus.NOT_READY)) {
-      return AllProviderStatus.NOT_READY;
-    } else if (statuses.includes(AllProviderStatus.ERROR)) {
-      return AllProviderStatus.ERROR;
-    } else if (statuses.includes(AllProviderStatus.STALE)) {
-      return AllProviderStatus.STALE;
+    if (statuses.includes(this.statusEnum.FATAL)) {
+      return this.statusEnum.FATAL;
+    } else if (statuses.includes(this.statusEnum.NOT_READY)) {
+      return this.statusEnum.NOT_READY;
+    } else if (statuses.includes(this.statusEnum.ERROR)) {
+      return this.statusEnum.ERROR;
+    } else if (statuses.includes(this.statusEnum.STALE)) {
+      return this.statusEnum.STALE;
     }
-    return AllProviderStatus.READY;
+    return this.statusEnum.READY;
   }
 
-  private changeProviderStatus(name: string, status: AllProviderStatus, details?: EventDetails) {
+  private changeProviderStatus(name: string, status: TProviderStatus, details?: EventDetails) {
     const currentStatus = this.getStatusFromProviderStatuses();
     this.providerStatuses[name] = status;
     const newStatus = this.getStatusFromProviderStatuses();
     if (currentStatus !== newStatus) {
-      if (newStatus === AllProviderStatus.FATAL || newStatus === AllProviderStatus.ERROR) {
-        this.events.emit(AllProviderEvents.Error, details);
-      } else if (newStatus === AllProviderStatus.STALE) {
-        this.events.emit(AllProviderEvents.Stale, details);
-      } else if (newStatus === AllProviderStatus.READY) {
-        this.events.emit(AllProviderEvents.Ready, details);
+      if (newStatus === this.statusEnum.FATAL || newStatus === this.statusEnum.ERROR) {
+        this.events.emit(this.eventEnum.Error as TProviderEvents, details);
+      } else if (newStatus === this.statusEnum.STALE) {
+        this.events.emit(this.eventEnum.Stale as TProviderEvents, details);
+      } else if (newStatus === this.statusEnum.READY) {
+        this.events.emit(this.eventEnum.Ready as TProviderEvents, details);
       }
     }
   }