Ofrep contract tests

package.json

@@ -36,6 +36,9 @@
     "url": "https://github.com/open-feature/flagd-ofrep-cf-worker.git"
   },
   "devDependencies": {
+    "@openfeature/ofrep-core": "^2.0.0",
+    "@openfeature/ofrep-provider": "^0.2.3",
+    "@openfeature/server-sdk": "^1.20.2",
     "@types/imurmurhash": "^0.1.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^24.0.0",

packages/js-ofrep-worker/src/flag-store.ts

@@ -41,7 +41,7 @@ export interface TypedResolutionResult<T> {
  */
 export interface EvaluationDetails {
   flagKey: string;
-  value: JsonValue;
+  value: JsonValue | undefined;
   variant?: string;
   reason?: string;
   errorCode?: string;
@@ -95,6 +95,13 @@ export class FlagStore {
     return Array.from(this.core.getFlags().keys());
   }
 
+  private mergeFlagMetadata(flagMetadata?: FlagMetadata): FlagMetadata {
+    return {
+      ...this.flagSetMetadata,
+      ...(flagMetadata || {}),
+    };
+  }
+
   /**
    * Resolve a boolean flag value
    */
@@ -190,10 +197,8 @@ export class FlagStore {
     if (flag.state === 'DISABLED') {
       return {
         value: undefined,
-        reason: StandardResolutionReasons.ERROR,
-        errorCode: ErrorCode.FLAG_NOT_FOUND,
-        errorMessage: `flag '${flagKey}' is disabled`,
-        flagMetadata: flag.metadata,
+        reason: StandardResolutionReasons.DISABLED,
+        flagMetadata: this.mergeFlagMetadata(flag.metadata),
       };
     }
 
@@ -210,18 +215,20 @@ export class FlagStore {
   }
 
   /**
-   * Resolve all enabled flags
+   * Resolve all configured flags, including code-default deferrals.
    */
   resolveAll(context: EvaluationContext = {}): EvaluationDetails[] {
-    const results = this.core.resolveAll(context);
-    return results.map((result) => ({
-      flagKey: result.flagKey,
-      value: result.value,
-      variant: result.variant,
-      reason: result.reason,
-      errorCode: result.errorCode,
-      errorMessage: result.errorMessage,
-      flagMetadata: result.flagMetadata,
-    }));
+    return this.getFlagKeys().map((flagKey) => {
+      const result = this.resolveValue(flagKey, context);
+      return {
+        flagKey,
+        value: result.value,
+        variant: result.variant,
+        reason: result.reason,
+        errorCode: result.errorCode,
+        errorMessage: result.errorMessage,
+        flagMetadata: result.flagMetadata,
+      };
+    });
   }
 }

packages/js-ofrep-worker/src/ofrep-handler.ts

@@ -203,7 +203,7 @@ export class OfrepHandler {
     // Success response
     const response: OfrepEvaluationSuccess = {
       key: flagKey,
-      value: result.value as JsonValue,
+      value: result.value,
       reason: toOfrepReason(result.reason),
       variant: result.variant,
       metadata: result.flagMetadata as Record<string, JsonValue> | undefined,
@@ -249,7 +249,7 @@ export class OfrepHandler {
 
       return {
         key: evaluation.flagKey,
-        value: evaluation.value as JsonValue,
+        value: evaluation.value,
         reason: toOfrepReason(evaluation.reason),
         variant: evaluation.variant,
         metadata: evaluation.flagMetadata as Record<string, JsonValue> | undefined,

packages/js-ofrep-worker/src/types.ts

@@ -27,7 +27,8 @@ export interface OfrepBulkEvaluationRequest {
  */
 export interface OfrepEvaluationSuccess {
   key: string;
-  value: JsonValue;
+  // OFREP may omit value to indicate the provider should use the code default.
+  value?: JsonValue;
   reason: OfrepReason;
   variant?: string;
   metadata?: Record<string, JsonValue>;

packages/js-ofrep-worker/test/flag-store.spec.ts

@@ -103,11 +103,15 @@ describe('FlagStore', () => {
       expect(result.errorMessage).toContain('not found');
     });
 
-    it('should return error for disabled flag', () => {
+    it('should defer to code defaults for disabled flag', () => {
       const result = store.resolveValue('disabled-flag');
       expect(result.value).toBeUndefined();
-      expect(result.errorCode).toBe('FLAG_NOT_FOUND');
-      expect(result.errorMessage).toContain('disabled');
+      expect(result.reason).toBe('DISABLED');
+      expect(result.errorCode).toBeUndefined();
+      expect(result.flagMetadata).toEqual({
+        flagSetId: 'test-flags',
+        version: '1.0.0',
+      });
     });
   });
 
@@ -180,15 +184,14 @@ describe('FlagStore', () => {
   });
 
   describe('resolveAll', () => {
-    it('should resolve all enabled flags', () => {
+    it('should resolve all configured flags', () => {
       const results = store.resolveAll();
       expect(results.length).toBeGreaterThan(0);
 
       const flagKeys = results.map((r) => r.flagKey);
       expect(flagKeys).toContain('simple-boolean');
       expect(flagKeys).toContain('simple-string');
-      // disabled flags should still appear but may have error
-      expect(flagKeys).not.toContain('disabled-flag');
+      expect(flagKeys).toContain('disabled-flag');
     });
 
     it('should include flag values in results', () => {
@@ -204,5 +207,22 @@ describe('FlagStore', () => {
       expect(targeted).toBeDefined();
       expect(targeted!.value).toBe(true);
     });
+
+    it('should include disabled flags as code-default results', () => {
+      const results = store.resolveAll();
+      const disabled = results.find((r) => r.flagKey === 'disabled-flag');
+
+      expect(disabled).toBeDefined();
+      expect(disabled).toMatchObject({
+        flagKey: 'disabled-flag',
+        reason: 'DISABLED',
+        flagMetadata: {
+          flagSetId: 'test-flags',
+          version: '1.0.0',
+        },
+      });
+      expect(disabled!.value).toBeUndefined();
+      expect(disabled!.errorCode).toBeUndefined();
+    });
   });
 });