fixup: compilation issue with server

Signed-off-by: Todd Baert <[email protected]>

Author: toddbaert

libs/hooks/debounce/src/lib/debounce-hook.spec.ts

@@ -1,7 +1,9 @@
 import type { EvaluationDetails, BaseHook, HookContext } from '@openfeature/core';
 import { DebounceHook } from './debounce-hook';
 import type { Hook as WebSdkHook } from '@openfeature/web-sdk';
+import { OpenFeature as OpenFeatureWeb } from '@openfeature/web-sdk';
 import type { Hook as ServerSdkHook } from '@openfeature/server-sdk';
+import { OpenFeature as OpenFeaturServer } from '@openfeature/server-sdk';
 
 describe('DebounceHook', () => {
   describe('caching', () => {
@@ -203,6 +205,23 @@ describe('DebounceHook', () => {
 
   describe('SDK compatibility', () => {
     describe('web-sdk hooks', () => {
+      it('should have type compatibility with API, client, evaluation', () => {
+        const webSdkHook = {} as WebSdkHook;
+
+        const hook = new DebounceHook<number>(webSdkHook, {
+          debounceTime: 60_000,
+          maxCacheItems: 100,
+        });
+
+        OpenFeatureWeb.addHooks(hook);
+        const client = OpenFeatureWeb.getClient().addHooks(hook);
+        client.getBooleanValue('flag', false, { hooks: [hook] });
+
+        // these expectations are silly, the real test here is making sure the above compiles
+        expect(OpenFeatureWeb.getHooks().length).toEqual(1);
+        expect(client.getHooks().length).toEqual(1);
+      });
+
       it('should debounce synchronous hooks', () => {
         const innerWebSdkHook: WebSdkHook = {
           before: jest.fn(),
@@ -239,6 +258,23 @@ describe('DebounceHook', () => {
       const contextKey = 'key';
       const contextValue = 'value';
       const evaluationContext = { [contextKey]: contextValue };
+      it('should have type compatibility with API, client, evaluation', () => {
+        const serverHook = {} as ServerSdkHook;
+
+        const hook = new DebounceHook<number>(serverHook, {
+          debounceTime: 60_000,
+          maxCacheItems: 100,
+        });
+
+        OpenFeaturServer.addHooks(hook);
+        const client = OpenFeaturServer.getClient().addHooks(hook);
+        client.getBooleanValue('flag', false, {}, { hooks: [hook] });
+
+        // these expectations are silly, the real test here is making sure the above compiles
+        expect(OpenFeaturServer.getHooks().length).toEqual(1);
+        expect(client.getHooks().length).toEqual(1);
+      });
+
       it('should debounce synchronous hooks', () => {
         const innerServerSdkHook: ServerSdkHook = {
           before: jest.fn(() => {

libs/hooks/debounce/src/lib/debounce-hook.ts

@@ -81,7 +81,15 @@ export type Options = {
  * The cacheKeySupplier is used to generate a cache key for the hook, which is used to determine if the hook should be executed or skipped.
  * If no cache key supplier is provided for a stage, that stage will always run.
  */
-export class DebounceHook<T extends FlagValue = FlagValue> implements BaseHook {
+export class DebounceHook<T extends FlagValue = FlagValue>
+  implements
+    BaseHook<
+      T,
+      Record<string, unknown>,
+      Promise<EvaluationContext | void> | EvaluationContext | void,
+      Promise<void> | void
+    >
+{
   private readonly cache: FixedSizeExpiringCache<HookStagesEntry>;
   private readonly cacheErrors: boolean;
   private readonly cacheKeySupplier: Options['cacheKeySupplier'];
@@ -136,11 +144,11 @@ export class DebounceHook<T extends FlagValue = FlagValue> implements BaseHook {
     );
   }
 
-  private maybeSkipAndCache(
+  private maybeSkipAndCache<T extends Promise<EvaluationContext | void> | EvaluationContext | void>(
     stage: Stage,
     keyGenCallback: () => string | null | undefined,
-    hookCallback: () => Promise<EvaluationContext | void> | EvaluationContext | void,
-  ) {
+    hookCallback: () => T,
+  ): T | void {
     // the cache key is a concatenation of the result of calling keyGenCallback and the stage
     let dynamicKey: string | null | undefined;
 
@@ -172,9 +180,9 @@ export class DebounceHook<T extends FlagValue = FlagValue> implements BaseHook {
         // already ran this stage for this key and is still in the debounce period
         if (typeof cachedStageResult === 'object') {
           // we have a cached context to return
-          return cachedStageResult;
+          return cachedStageResult as T;
         }
-        return;
+        return; // cached run with void return
       }
     }