fix: reset API state on close

Implements spec requirement 1.6.2: close() now fully resets all
API-managed state after provider shutdown, including providers,
global and domain-scoped hooks, event handlers, global evaluation
context, domain-scoped evaluation context, and (server) transaction
context propagator.

clearProviders() remains provider-only for backward compatibility,
as guided by the maintainers.

Fixes #1374.

Signed-off-by: Krishan Kant Sharma <krishansharma0327@gmail.com>

Author: Krishan27

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

@@ -19,25 +19,6 @@ describe('OpenFeatureModule', () => {
       await moduleRef.close();
     });
 
-    describe('without configured providers', () => {
-      let moduleWithoutProvidersRef: TestingModule;
-      beforeAll(async () => {
-        moduleWithoutProvidersRef = await Test.createTestingModule({
-          imports: [OpenFeatureModule.forRoot({})],
-        }).compile();
-      });
-
-      afterAll(async () => {
-        await moduleWithoutProvidersRef.close();
-      });
-
-      it('should return the SDKs default provider and not throw', async () => {
-        expect(() => {
-          moduleWithoutProvidersRef.get<Client>(getOpenFeatureClientToken());
-        }).not.toThrow();
-      });
-    });
-
     it('should return the default provider', async () => {
       const client = moduleRef.get<Client>(getOpenFeatureClientToken());
       expect(client).toBeDefined();
@@ -91,6 +72,27 @@ describe('OpenFeatureModule', () => {
         OpenFeature.clearHooks();
       }
     });
+
+    // Placed after provider-dependent tests: closing this inner module calls OpenFeature.close()
+    // which now fully resets API state per spec requirement 1.6.2.
+    describe('without configured providers', () => {
+      let moduleWithoutProvidersRef: TestingModule;
+      beforeAll(async () => {
+        moduleWithoutProvidersRef = await Test.createTestingModule({
+          imports: [OpenFeatureModule.forRoot({})],
+        }).compile();
+      });
+
+      afterAll(async () => {
+        await moduleWithoutProvidersRef.close();
+      });
+
+      it('should return the SDKs default provider and not throw', async () => {
+        expect(() => {
+          moduleWithoutProvidersRef.get<Client>(getOpenFeatureClientToken());
+        }).not.toThrow();
+      });
+    });
   });
 
   describe('handlers', () => {

packages/server/src/open-feature.ts

@@ -219,6 +219,13 @@ export class OpenFeatureAPI
     );
   }
 
+  async close(): Promise<void> {
+    await super.close();
+    this._domainScopedProviders.clear();
+    this._defaultProvider = new ProviderWrapper(NOOP_PROVIDER, ProviderStatus.NOT_READY, this._statusEnumType);
+    this._transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
+  }
+
   /**
    * Clears all registered providers and resets the default provider.
    * @returns {Promise<void>}

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

@@ -1,6 +1,6 @@
 import type { Paradigm } from '@openfeature/core';
-import type { Provider, ProviderStatus } from '../src';
-import { OpenFeature, OpenFeatureAPI } from '../src';
+import type { Hook, Provider, ProviderStatus, TransactionContextPropagator } from '../src';
+import { NOOP_PROVIDER, OpenFeature, OpenFeatureAPI, ProviderEvents } from '../src';
 import { OpenFeatureClient } from '../src/client/internal/open-feature-client';
 
 const mockProvider = (config?: { initialStatus?: ProviderStatus; runsOn?: Paradigm }) => {
@@ -230,4 +230,94 @@ describe('OpenFeature', () => {
       expect(provider3.onClose).toHaveBeenCalled();
     });
   });
+
+  describe('Requirement 1.6.2', () => {
+    it('resets the default provider to no-op after close()', async () => {
+      const provider = mockProvider();
+      OpenFeature.setProvider(provider);
+      expect(OpenFeature.providerMetadata.name).toBe('mock-events-success');
+      await OpenFeature.close();
+      expect(OpenFeature.providerMetadata.name).toBe(NOOP_PROVIDER.metadata.name);
+    });
+
+    it('clears domain-scoped providers after close()', async () => {
+      const provider = mockProvider();
+      OpenFeature.setProvider('domain1', provider);
+      expect(OpenFeature.getProvider('domain1')).toBe(provider);
+      await OpenFeature.close();
+      expect(OpenFeature.getProvider('domain1').metadata.name).toBe(NOOP_PROVIDER.metadata.name);
+    });
+
+    it('clears global hooks after close()', async () => {
+      const hook = { before: jest.fn() } as unknown as Hook;
+      OpenFeature.addHooks(hook);
+      expect(OpenFeature.getHooks()).toHaveLength(1);
+      await OpenFeature.close();
+      expect(OpenFeature.getHooks()).toHaveLength(0);
+    });
+
+    it('clears global evaluation context after close()', async () => {
+      OpenFeature.setContext({ user: 'test' });
+      expect(OpenFeature.getContext()).toEqual({ user: 'test' });
+      await OpenFeature.close();
+      expect(OpenFeature.getContext()).toEqual({});
+    });
+
+    it('removes API-level event handlers after close()', async () => {
+      const handler = jest.fn();
+      OpenFeature.addHandler(ProviderEvents.Ready, handler);
+      expect(OpenFeature.getHandlers(ProviderEvents.Ready)).toHaveLength(1);
+      await OpenFeature.close();
+      expect(OpenFeature.getHandlers(ProviderEvents.Ready)).toHaveLength(0);
+    });
+
+    it('resets the transaction context propagator to the default after close()', async () => {
+      const customPropagator: TransactionContextPropagator = {
+        getTransactionContext: jest.fn(() => ({ custom: true })),
+        setTransactionContext: jest.fn(),
+      };
+      OpenFeature.setTransactionContextPropagator(customPropagator);
+      expect(OpenFeature.getTransactionContext()).toEqual({ custom: true });
+      await OpenFeature.close();
+      expect(OpenFeature.getTransactionContext()).toEqual({});
+    });
+  });
+
+  describe('clearProviders() remains provider-only', () => {
+    afterEach(async () => {
+      OpenFeature.clearHooks();
+      OpenFeature.clearHandlers();
+      OpenFeature.setContext({});
+    });
+
+    it('does not clear global hooks', async () => {
+      const hook = { before: jest.fn() } as unknown as Hook;
+      OpenFeature.addHooks(hook);
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getHooks()).toHaveLength(1);
+    });
+
+    it('does not clear global evaluation context', async () => {
+      OpenFeature.setContext({ user: 'test' });
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getContext()).toEqual({ user: 'test' });
+    });
+
+    it('does not remove API-level event handlers', async () => {
+      const handler = jest.fn();
+      OpenFeature.addHandler(ProviderEvents.Ready, handler);
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getHandlers(ProviderEvents.Ready)).toHaveLength(1);
+    });
+
+    it('does not reset the transaction context propagator', async () => {
+      const customPropagator: TransactionContextPropagator = {
+        getTransactionContext: jest.fn(() => ({ custom: true })),
+        setTransactionContext: jest.fn(),
+      };
+      OpenFeature.setTransactionContextPropagator(customPropagator);
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getTransactionContext()).toEqual({ custom: true });
+    });
+  });
 });

packages/shared/src/open-feature.ts

@@ -395,6 +395,31 @@ export abstract class OpenFeatureCommonAPI<
   }
 
   async close(): Promise<void> {
+    await this._shutdownAllProviders();
+    this._hooks = [];
+    this._context = {};
+    this._domainScopedContext.clear();
+    this._clientEventHandlers.clear();
+    this._clientEvents.clear();
+    this._apiEmitter.removeAllHandlers();
+  }
+
+  protected async clearProvidersAndSetDefault(defaultProvider: P): Promise<void> {
+    try {
+      await this._shutdownAllProviders();
+    } catch (err) {
+      this._logger.error('Unable to cleanly close providers. Resetting to the default configuration.');
+    } finally {
+      this._domainScopedProviders.clear();
+      this._defaultProvider = new ProviderWrapper<P, AnyProviderStatus>(
+        defaultProvider,
+        this._statusEnumType.NOT_READY,
+        this._statusEnumType,
+      );
+    }
+  }
+
+  private async _shutdownAllProviders(): Promise<void> {
     try {
       await this?._defaultProvider.provider?.onClose?.();
     } catch (err) {
@@ -414,21 +439,6 @@ export abstract class OpenFeatureCommonAPI<
     );
   }
 
-  protected async clearProvidersAndSetDefault(defaultProvider: P): Promise<void> {
-    try {
-      await this.close();
-    } catch (err) {
-      this._logger.error('Unable to cleanly close providers. Resetting to the default configuration.');
-    } finally {
-      this._domainScopedProviders.clear();
-      this._defaultProvider = new ProviderWrapper<P, AnyProviderStatus>(
-        defaultProvider,
-        this._statusEnumType.NOT_READY,
-        this._statusEnumType,
-      );
-    }
-  }
-
   private get allProviders(): P[] {
     return [
       ...[...this._domainScopedProviders.values()].map((wrappers) => wrappers.provider),

packages/web/src/open-feature.ts

@@ -361,6 +361,12 @@ export class OpenFeatureAPI
     );
   }
 
+  async close(): Promise<void> {
+    await super.close();
+    this._domainScopedProviders.clear();
+    this._defaultProvider = new ProviderWrapper(NOOP_PROVIDER, ProviderStatus.NOT_READY, this._statusEnumType);
+  }
+
   /**
    * Clears all registered providers and resets the default provider.
    * @returns {Promise<void>}

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

@@ -1,6 +1,6 @@
 import type { Paradigm } from '@openfeature/core';
-import type { Provider } from '../src';
-import { OpenFeature, OpenFeatureAPI, ProviderStatus } from '../src';
+import type { Hook, Provider } from '../src';
+import { NOOP_PROVIDER, OpenFeature, OpenFeatureAPI, ProviderEvents, ProviderStatus } from '../src';
 import { OpenFeatureClient } from '../src/client/internal/open-feature-client';
 
 const mockProvider = (config?: { initialStatus?: ProviderStatus; runsOn?: Paradigm }) => {
@@ -256,4 +256,80 @@ describe('OpenFeature', () => {
       });
     });
   });
+
+  describe('Requirement 1.6.2', () => {
+    it('resets the default provider to no-op after close()', async () => {
+      const provider = mockProvider();
+      OpenFeature.setProvider(provider);
+      expect(OpenFeature.providerMetadata.name).toBe('mock-events-success');
+      await OpenFeature.close();
+      expect(OpenFeature.providerMetadata.name).toBe(NOOP_PROVIDER.metadata.name);
+    });
+
+    it('clears domain-scoped providers after close()', async () => {
+      const provider = mockProvider();
+      OpenFeature.setProvider('domain1', provider);
+      expect(OpenFeature.getProvider('domain1')).toBe(provider);
+      await OpenFeature.close();
+      expect(OpenFeature.getProvider('domain1').metadata.name).toBe(NOOP_PROVIDER.metadata.name);
+    });
+
+    it('clears global hooks after close()', async () => {
+      const hook = { before: jest.fn() } as unknown as Hook;
+      OpenFeature.addHooks(hook);
+      expect(OpenFeature.getHooks()).toHaveLength(1);
+      await OpenFeature.close();
+      expect(OpenFeature.getHooks()).toHaveLength(0);
+    });
+
+    it('clears global evaluation context after close()', async () => {
+      await OpenFeature.setContext({ user: 'test' });
+      expect(OpenFeature.getContext()).toEqual({ user: 'test' });
+      await OpenFeature.close();
+      expect(OpenFeature.getContext()).toEqual({});
+    });
+
+    it('clears domain-scoped evaluation context after close()', async () => {
+      await OpenFeature.setContext('domain1', { user: 'test' });
+      expect(OpenFeature.getContext('domain1')).toEqual({ user: 'test' });
+      await OpenFeature.close();
+      expect(OpenFeature.getContext('domain1')).toEqual({});
+    });
+
+    it('removes API-level event handlers after close()', async () => {
+      const handler = jest.fn();
+      OpenFeature.addHandler(ProviderEvents.Ready, handler);
+      expect(OpenFeature.getHandlers(ProviderEvents.Ready)).toHaveLength(1);
+      await OpenFeature.close();
+      expect(OpenFeature.getHandlers(ProviderEvents.Ready)).toHaveLength(0);
+    });
+  });
+
+  describe('clearProviders() remains provider-only', () => {
+    afterEach(async () => {
+      OpenFeature.clearHooks();
+      OpenFeature.clearHandlers();
+      await OpenFeature.setContext({});
+    });
+
+    it('does not clear global hooks', async () => {
+      const hook = { before: jest.fn() } as unknown as Hook;
+      OpenFeature.addHooks(hook);
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getHooks()).toHaveLength(1);
+    });
+
+    it('does not clear global evaluation context', async () => {
+      await OpenFeature.setContext({ user: 'test' });
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getContext()).toEqual({ user: 'test' });
+    });
+
+    it('does not remove API-level event handlers', async () => {
+      const handler = jest.fn();
+      OpenFeature.addHandler(ProviderEvents.Ready, handler);
+      await OpenFeature.clearProviders();
+      expect(OpenFeature.getHandlers(ProviderEvents.Ready)).toHaveLength(1);
+    });
+  });
 });