feat!: use native headers, optional query params (open-feature#1003)

Signed-off-by: Todd Baert <todd.baert@dynatrace.com>

Author: toddbaert

libs/providers/ofrep-web/package.json

@@ -11,7 +11,6 @@
     "current-version": "echo $npm_package_version"
   },
   "peerDependencies": {
-    "@openfeature/web-sdk": ">=0.4.0",
-    "@openfeature/ofrep-core": "^0.1.5"
+    "@openfeature/web-sdk": ">=0.4.0"
   }
 }

libs/providers/ofrep-web/project.json

@@ -68,7 +68,8 @@
             "input": "./libs/providers/ofrep-web",
             "output": "./"
           }
-        ]
+        ],
+        "updateBuildableProjectDepsInPackageJson": true
       }
     }
   },

libs/providers/ofrep-web/src/lib/ofrep-web-provider.ts

@@ -13,7 +13,6 @@ import {
   OFREPApiTooManyRequestsError,
   OFREPApiUnauthorizedError,
   OFREPForbiddenError,
-  RequestOptions,
   handleEvaluationError,
   isEvaluationFailureResponse,
   isEvaluationSuccessResponse,
@@ -66,7 +65,7 @@ export class OFREPWebProvider implements Provider {
     this._options = options;
     this._logger = logger;
     this._etag = null;
-    this._ofrepAPI = new OFREPApi(this._options.baseUrl, this._options.fetchImplementation);
+    this._ofrepAPI = new OFREPApi(this._options, this._options.fetchImplementation);
     this._pollingInterval = this._options.pollInterval ?? this.DEFAULT_POLL_INTERVAL;
   }
 
@@ -189,14 +188,8 @@ export class OFREPWebProvider implements Provider {
       const evalReq: EvaluationRequest = {
         context,
       };
-      const options: RequestOptions = {
-        headers: new Headers({
-          'Content-Type': 'application/json',
-        }),
-        ...(this._etag !== null ? { headers: { 'If-None-Match': this._etag } } : {}),
-      };
 
-      const response = await this._ofrepAPI.postBulkEvaluateFlags(evalReq, options);
+      const response = await this._ofrepAPI.postBulkEvaluateFlags(evalReq, this._etag);
       if (response.httpStatus === 304) {
         // nothing has changed since last time, we are doing nothing
         return { status: BulkEvaluationStatus.SUCCESS_NO_CHANGES, flags: [] };

libs/providers/ofrep/package.json

@@ -11,7 +11,6 @@
     "current-version": "echo $npm_package_version"
   },
   "peerDependencies": {
-    "@openfeature/server-sdk": "^1.6.0",
-    "@openfeature/ofrep-core": "^0.1.4"
+    "@openfeature/server-sdk": "^1.6.0"
   }
 }

libs/providers/ofrep/project.json

@@ -68,7 +68,8 @@
             "input": "./libs/providers/ofrep",
             "output": "./"
           }
-        ]
+        ],
+        "updateBuildableProjectDepsInPackageJson": true
       }
     }
   },

libs/providers/ofrep/src/lib/ofrep-provider.spec.ts

@@ -54,7 +54,7 @@ describe('OFREPProvider should', () => {
       OFREPApiUnauthorizedError,
     );
 
-    const providerWithAuth = new OFREPProvider({ ...defaultOptions, headers: { Authorization: 'secret' } });
+    const providerWithAuth = new OFREPProvider({ ...defaultOptions, headers: [['Authorization', 'secret']] });
     const flag = await providerWithAuth.resolveBooleanEvaluation('my-flag', false, { expectedAuthHeader: 'secret' });
     expect(flag.value).toEqual(true);
   });
@@ -154,7 +154,7 @@ describe('OFREPProvider should', () => {
 
     const providerWithAuth = new OFREPProvider({
       ...defaultOptions,
-      headersFactory: () => [['Authorization', 'secret']],
+      headersFactory: () => Promise.resolve([['Authorization', 'secret']]),
     });
     const flag = await providerWithAuth.resolveBooleanEvaluation('my-flag', false, { expectedAuthHeader: 'secret' });
     expect(flag.value).toEqual(true);

libs/providers/ofrep/src/lib/ofrep-provider.ts

@@ -1,30 +1,16 @@
-import {
-  ErrorCode,
-  EvaluationContext,
-  JsonValue,
-  Provider,
-  ResolutionDetails,
-  StandardResolutionReasons,
-  TypeMismatchError,
-} from '@openfeature/server-sdk';
+import { GeneralError } from '@openfeature/core';
 import {
   EvaluationFlagValue,
-  handleEvaluationError,
-  HttpHeaders,
-  mergeHeaders,
   OFREPApi,
   OFREPApiEvaluationResult,
   OFREPApiTooManyRequestsError,
   OFREPProviderBaseOptions,
-  RequestOptions,
-  toRequestOptions,
+  handleEvaluationError,
   toResolutionDetails,
 } from '@openfeature/ofrep-core';
-import { GeneralError } from '@openfeature/core';
+import { EvaluationContext, JsonValue, Provider, ResolutionDetails, TypeMismatchError } from '@openfeature/server-sdk';
 
-export type OFREPProviderOptions = Omit<OFREPProviderBaseOptions, 'headersFactory'> & {
-  headersFactory?: () => Promise<HttpHeaders> | HttpHeaders;
-};
+export type OFREPProviderOptions = OFREPProviderBaseOptions;
 
 export class OFREPProvider implements Provider {
   private notBefore: Date | null = null;
@@ -43,7 +29,7 @@ export class OFREPProvider implements Provider {
       throw new Error(`The given OFREP URL "${this.options.baseUrl}" is not a valid URL.`);
     }
 
-    this.ofrepApi = new OFREPApi(options.baseUrl, options.fetchImplementation);
+    this.ofrepApi = new OFREPApi(options, options.fetchImplementation);
   }
 
   public async resolveBooleanEvaluation(
@@ -91,7 +77,7 @@ export class OFREPProvider implements Provider {
     }
 
     try {
-      const result = await this.ofrepApi.postEvaluateFlags(flagKey, { context }, await this.baseRequestOptions());
+      const result = await this.ofrepApi.postEvaluateFlag(flagKey, { context });
       return this.toResolutionDetails(result, defaultValue);
     } catch (error) {
       if (error instanceof OFREPApiTooManyRequestsError) {
@@ -115,12 +101,4 @@ export class OFREPProvider implements Provider {
 
     return toResolutionDetails(result.value);
   }
-
-  private async baseRequestOptions(): Promise<RequestOptions> {
-    const { headers, headersFactory, ...restOptions } = this.options;
-    return {
-      ...toRequestOptions(restOptions),
-      headers: mergeHeaders(headers, await headersFactory?.()),
-    };
-  }
 }

libs/shared/ofrep-core/src/lib/api/ofrep-api.spec.ts

@@ -25,7 +25,7 @@ describe('OFREPApi', () => {
   });
   beforeEach(() => {
     jest.useFakeTimers();
-    api = new OFREPApi('https://localhost:8080');
+    api = new OFREPApi({ baseUrl: 'https://localhost:8080' });
   });
   afterEach(() => {
     jest.runOnlyPendingTimers();
@@ -38,31 +38,31 @@ describe('OFREPApi', () => {
 
   describe('postEvaluateFlags should', () => {
     it('throw OFREPApiFetchError on network error', async () => {
-      await expect(() => api.postEvaluateFlags('my-flag', { context: { errors: { network: true } } })).rejects.toThrow(
+      await expect(() => api.postEvaluateFlag('my-flag', { context: { errors: { network: true } } })).rejects.toThrow(
         OFREPApiFetchError,
       );
     });
 
     it('throw OFREPApiUnexpectedResponseError on any error code without EvaluationFailureResponse body', async () => {
       await expect(() =>
-        api.postEvaluateFlags('my-flag', { context: { errors: { generic400: true } } }),
+        api.postEvaluateFlag('my-flag', { context: { errors: { generic400: true } } }),
       ).rejects.toThrow(OFREPApiUnexpectedResponseError);
     });
 
     it('throw OFREPForbiddenError on 401 response', async () => {
-      await expect(() => api.postEvaluateFlags('my-flag', { context: { errors: { 401: true } } })).rejects.toThrow(
+      await expect(() => api.postEvaluateFlag('my-flag', { context: { errors: { 401: true } } })).rejects.toThrow(
         OFREPApiUnauthorizedError,
       );
     });
 
     it('throw OFREPForbiddenError on 403 response', async () => {
-      await expect(() => api.postEvaluateFlags('my-flag', { context: { errors: { 403: true } } })).rejects.toThrow(
+      await expect(() => api.postEvaluateFlag('my-flag', { context: { errors: { 403: true } } })).rejects.toThrow(
         OFREPForbiddenError,
       );
     });
 
     it('throw OFREPApiTooManyRequestsError on 429 response', async () => {
-      await expect(() => api.postEvaluateFlags('my-flag', { context: { errors: { 429: true } } })).rejects.toThrow(
+      await expect(() => api.postEvaluateFlag('my-flag', { context: { errors: { 429: true } } })).rejects.toThrow(
         OFREPApiTooManyRequestsError,
       );
     });
@@ -71,7 +71,7 @@ describe('OFREPApi', () => {
       jest.setSystemTime(new Date('2018-01-27'));
 
       try {
-        await api.postEvaluateFlags('my-flag', { context: { errors: { 429: true } } });
+        await api.postEvaluateFlag('my-flag', { context: { errors: { 429: true } } });
       } catch (error) {
         if (!(error instanceof OFREPApiTooManyRequestsError)) {
           throw new Error('Expected OFREPApiTooManyRequestsError');
@@ -86,7 +86,7 @@ describe('OFREPApi', () => {
       jest.setSystemTime(new Date('2018-01-27'));
 
       try {
-        await api.postEvaluateFlags('my-flag', { context: { errors: { 429: 'Sat, 27 Jan 2018 07:28:00 GMT' } } });
+        await api.postEvaluateFlag('my-flag', { context: { errors: { 429: 'Sat, 27 Jan 2018 07:28:00 GMT' } } });
       } catch (error) {
         if (!(error instanceof OFREPApiTooManyRequestsError)) {
           throw new Error('Expected OFREPApiTooManyRequestsError');
@@ -101,7 +101,7 @@ describe('OFREPApi', () => {
       jest.setSystemTime(new Date('2018-01-27'));
 
       try {
-        await api.postEvaluateFlags('my-flag', { context: { errors: { 429: 'abcdefg' } } });
+        await api.postEvaluateFlag('my-flag', { context: { errors: { 429: 'abcdefg' } } });
       } catch (error) {
         if (!(error instanceof OFREPApiTooManyRequestsError)) {
           throw new Error('Expected OFREPApiTooManyRequestsError');
@@ -113,12 +113,12 @@ describe('OFREPApi', () => {
     });
 
     it('send empty request body if context is not given', async () => {
-      const result = await api.postEvaluateFlags('my-flag');
+      const result = await api.postEvaluateFlag('my-flag');
       expect(result.httpStatus).toEqual(200);
     });
 
     it('send evaluation context in request body', async () => {
-      const result = await api.postEvaluateFlags('context-in-metadata', {
+      const result = await api.postEvaluateFlag('context-in-metadata', {
         context: {
           targetingKey: 'user-1',
           key1: 'value1',
@@ -138,12 +138,12 @@ describe('OFREPApi', () => {
     });
 
     it('return HTTP status in result', async () => {
-      const result = await api.postEvaluateFlags('my-flag');
+      const result = await api.postEvaluateFlag('my-flag');
       expect(result.httpStatus).toEqual(200);
     });
 
     it('return EvaluationFailureResponse response as value on HTTP 400', async () => {
-      const result = await api.postEvaluateFlags('my-flag', { context: { errors: { notFound: true } } });
+      const result = await api.postEvaluateFlag('my-flag', { context: { errors: { notFound: true } } });
       if (result.httpStatus !== 404) {
         throw new Error('Received unexpected HTTP status');
       }
@@ -155,7 +155,7 @@ describe('OFREPApi', () => {
     });
 
     it('return EvaluationFailureResponse response as value on HTTP 400', async () => {
-      const result = await api.postEvaluateFlags('my-flag', { context: { errors: { notFound: true } } });
+      const result = await api.postEvaluateFlag('my-flag', { context: { errors: { notFound: true } } });
       if (result.httpStatus !== 404) {
         throw new Error('Received unexpected HTTP status');
       }
@@ -167,7 +167,7 @@ describe('OFREPApi', () => {
     });
 
     it('determine value type based on HTTP status', async () => {
-      const result = await api.postEvaluateFlags('my-flag');
+      const result = await api.postEvaluateFlag('my-flag');
       expect(result.httpStatus).toEqual(200);
 
       // This is to check if the value type is determined by http status code
@@ -179,7 +179,7 @@ describe('OFREPApi', () => {
     });
 
     it('return EvaluationSuccessResponse response as value on successful evaluation', async () => {
-      const result = await api.postEvaluateFlags('my-flag', { context: { targetingKey: 'user' } });
+      const result = await api.postEvaluateFlag('my-flag', { context: { targetingKey: 'user' } });
       expect(result.httpStatus).toEqual(200);
       expect(result.value).toEqual({
         key: 'my-flag',
@@ -193,6 +193,23 @@ describe('OFREPApi', () => {
         },
       } satisfies EvaluationSuccessResponse);
     });
+
+    it('send query params with request', async () => {
+      api = new OFREPApi({ baseUrl: 'https://localhost:8080', query: new URLSearchParams({ scope: '123' }) });
+      const result = await api.postEvaluateFlag('my-flag', { context: { targetingKey: 'user' } });
+      expect(result.httpStatus).toEqual(200);
+      expect(result.value).toEqual({
+        key: 'my-flag',
+        reason: EvaluationSuccessReason.TargetingMatch,
+        value: true,
+        variant: 'scoped',
+        metadata: {
+          context: {
+            targetingKey: 'user',
+          },
+        },
+      } satisfies EvaluationSuccessResponse);
+    });
   });
 
   describe('postBulkEvaluateFlags should', () => {
@@ -302,11 +319,26 @@ describe('OFREPApi', () => {
     });
 
     it('return BulkEvaluationNotModified response as value on 304', async () => {
-      const result = await api.postBulkEvaluateFlags(undefined, { headers: [['If-None-Match', '1234']] });
+      api = new OFREPApi({ baseUrl: 'https://localhost:8080', headers: [['If-None-Match', '1234']] });
+      const result = await api.postBulkEvaluateFlags(undefined);
       expect(result.httpStatus).toEqual(304);
       expect(result.value).not.toBeDefined();
     });
 
+    it('send query params with request', async () => {
+      api = new OFREPApi({ baseUrl: 'https://localhost:8080', query: new URLSearchParams({ scope: '123' }) });
+      const result = await api.postBulkEvaluateFlags();
+      expect(result.httpStatus).toEqual(200);
+      expect(result.value).toEqual({
+        flags: [
+          {
+            key: 'other-flag',
+            value: true,
+          },
+        ],
+      });
+    });
+
     it('return BulkEvaluationSuccessResponse response as value on successful evaluation', async () => {
       const result = await api.postBulkEvaluateFlags();
       expect(result.httpStatus).toEqual(200);