feat: moving duplicate Multi-Provider resources to shared pacakge, WIP

# Conflicts:
#	packages/web/src/provider/multi-provider/status-tracker.ts

Author: jonathannorris

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

@@ -1,3 +1 @@
 export * from './multi-provider';
-export * from './errors';
-export * from './strategies';

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

@@ -13,17 +13,25 @@ import type {
   ProviderMetadata,
   ResolutionDetails,
   TrackingEventDetails,
+  BaseEvaluationStrategy,
+  ProviderResolutionResult,
+  ProviderEntryInput,
+  RegisteredProvider,
+} from '@openfeature/core';
+import {
+  DefaultLogger,
+  ErrorCode,
+  GeneralError,
+  StandardResolutionReasons,
+  constructAggregateError,
+  FirstMatchStrategy,
+  throwAggregateErrorFromPromiseResults,
+  StatusTracker,
 } from '@openfeature/core';
-import { DefaultLogger, ErrorCode, GeneralError, StandardResolutionReasons } from '@openfeature/core';
 import type { Provider } from '../provider';
 import type { Hook } from '../../hooks';
 import { OpenFeatureEventEmitter } from '../../events/open-feature-event-emitter';
-import { constructAggregateError, throwAggregateErrorFromPromiseResults } from './errors';
 import { HookExecutor } from './hook-executor';
-import { StatusTracker } from './status-tracker';
-import type { BaseEvaluationStrategy, ProviderResolutionResult } from './strategies';
-import { FirstMatchStrategy } from './strategies';
-import type { ProviderEntryInput, RegisteredProvider } from './types';
 
 export class MultiProvider implements Provider {
   readonly runsOn = 'server';

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

@@ -1,6 +1,6 @@
 import type { EventDetails } from '@openfeature/core';
-import type { OpenFeatureEventEmitter } from '../../events';
 import { ProviderEvents } from '../../events';
+import type { OpenFeatureEventEmitter } from '../../events/open-feature-event-emitter';
 import { ProviderStatus } from '../provider';
 import type { RegisteredProvider } from './types';
 

packages/server/src/provider/multi-provider/strategies/comparison-strategy.ts

@@ -1,10 +1,8 @@
-// Represents an entry in the constructor's provider array which may or may not have a name set
 import type { Provider } from '../provider';
 
 export type ProviderEntryInput = {
   provider: Provider;
   name?: string;
 };
 
-// Represents a processed and "registered" provider entry where a name has been chosen
 export type RegisteredProvider = Required<ProviderEntryInput>;

packages/server/src/provider/multi-provider/strategies/first-match-strategy.ts

@@ -1 +1,5 @@
 export * from './provider';
+export * from './multi-provider/errors';
+export * from './multi-provider/status-tracker';
+export * from './multi-provider/types';
+export * from './multi-provider/strategies';

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

@@ -1,5 +1,5 @@
-import type { ErrorCode } from '@openfeature/core';
-import { GeneralError, OpenFeatureError } from '@openfeature/core';
+import type { ErrorCode } from '../../evaluation';
+import { GeneralError, OpenFeatureError } from '../../errors';
 import type { RegisteredProvider } from './types';
 
 export class ErrorWithCode extends OpenFeatureError {

packages/shared/src/provider/index.ts

@@ -0,0 +1,66 @@
+import type { EventDetails, ProviderEventEmitter } from '../../events';
+import { AllProviderEvents } from '../../events';
+import { AllProviderStatus } from '../../provider';
+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> = {};
+
+  constructor(private events: ProviderEventEmitter<AllProviderEvents>) {}
+
+  wrapEventHandler(providerEntry: RegisteredProvider) {
+    const provider = providerEntry.provider;
+    provider.events?.addHandler(AllProviderEvents.Error, (details?: EventDetails) => {
+      this.changeProviderStatus(providerEntry.name, AllProviderStatus.ERROR, details);
+    });
+
+    provider.events?.addHandler(AllProviderEvents.Stale, (details?: EventDetails) => {
+      this.changeProviderStatus(providerEntry.name, AllProviderStatus.STALE, details);
+    });
+
+    provider.events?.addHandler(AllProviderEvents.ConfigurationChanged, (details?: EventDetails) => {
+      this.events.emit(AllProviderEvents.ConfigurationChanged, details);
+    });
+
+    provider.events?.addHandler(AllProviderEvents.Ready, (details?: EventDetails) => {
+      this.changeProviderStatus(providerEntry.name, AllProviderStatus.READY, details);
+    });
+  }
+
+  providerStatus(name: string) {
+    return this.providerStatuses[name];
+  }
+
+  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;
+    }
+    return AllProviderStatus.READY;
+  }
+
+  private changeProviderStatus(name: string, status: AllProviderStatus, 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);
+      }
+    }
+  }
+}

packages/server/src/provider/multi-provider/errors.ts renamed to packages/shared/src/provider/multi-provider/errors.ts

@@ -1,29 +1,25 @@
-import type {
-  ErrorCode,
-  EvaluationContext,
-  FlagValue,
-  FlagValueType,
-  OpenFeatureError,
-  ResolutionDetails,
-  TrackingEventDetails,
-} from '@openfeature/core';
-import type { Provider } from '../../provider';
-import { ProviderStatus } from '../../provider';
+import type { ErrorCode, EvaluationContext, FlagValue, FlagValueType, ResolutionDetails } from '../../../evaluation';
+import type { OpenFeatureError } from '../../../errors';
+import type { CommonProvider } from '../../../provider';
+import { AllProviderStatus } from '../../../provider';
 import { ErrorWithCode } from '../errors';
+import type { TrackingEventDetails } from '../../../tracking';
 
 export type StrategyEvaluationContext = {
   flagKey: string;
   flagType: FlagValueType;
 };
+
 export type StrategyProviderContext = {
-  provider: Provider;
+  provider: CommonProvider<AllProviderStatus>;
   providerName: string;
-  providerStatus: ProviderStatus;
+  providerStatus: AllProviderStatus;
 };
+
 export type StrategyPerProviderContext = StrategyEvaluationContext & StrategyProviderContext;
 
 type ProviderResolutionResultBase = {
-  provider: Provider;
+  provider: CommonProvider<AllProviderStatus>;
   providerName: string;
 };
 
@@ -41,25 +37,21 @@ export type ProviderResolutionResult<T extends FlagValue> =
 
 export type FinalResult<T extends FlagValue> = {
   details?: ResolutionDetails<T>;
-  provider?: Provider;
+  provider?: CommonProvider<AllProviderStatus>;
   providerName?: string;
   errors?: {
     providerName: string;
     error: unknown;
   }[];
 };
 
-/**
- * Base strategy to inherit from. Not directly usable, as strategies must implement the "determineResult" method
- * Contains default implementations for `shouldEvaluateThisProvider` and `shouldEvaluateNextProvider`
- */
 export abstract class BaseEvaluationStrategy {
   public runMode: 'parallel' | 'sequential' = 'sequential';
 
   shouldEvaluateThisProvider(strategyContext: StrategyPerProviderContext, _evalContext?: EvaluationContext): boolean {
     if (
-      strategyContext.providerStatus === ProviderStatus.NOT_READY ||
-      strategyContext.providerStatus === ProviderStatus.FATAL
+      strategyContext.providerStatus === AllProviderStatus.NOT_READY ||
+      strategyContext.providerStatus === AllProviderStatus.FATAL
     ) {
       return false;
     }
@@ -81,8 +73,8 @@ export abstract class BaseEvaluationStrategy {
     _trackingEventDetails?: TrackingEventDetails,
   ): boolean {
     if (
-      strategyContext.providerStatus === ProviderStatus.NOT_READY ||
-      strategyContext.providerStatus === ProviderStatus.FATAL
+      strategyContext.providerStatus === AllProviderStatus.NOT_READY ||
+      strategyContext.providerStatus === AllProviderStatus.FATAL
     ) {
       return false;
     }