chore: parse safety for api (#801)

Author: sighphyre

src/feature.ts

@@ -25,7 +25,9 @@ export interface EnhancedFeatureInterface extends Omit<FeatureInterface, 'strate
   strategies?: EnhancedStrategyTransportInterface[];
 }
 
-export type ApiResponse = ClientFeaturesDelta | ClientFeaturesResponse;
+export type ApiResponse =
+  | (ClientFeaturesDelta & { type: 'delta' })
+  | (ClientFeaturesResponse & { type: 'full' });
 
 export interface ClientFeaturesResponse {
   version: number;
@@ -38,16 +40,18 @@ export interface ClientFeaturesDelta {
   events: DeltaEvent[];
 }
 
-export const parseClientFeaturesDelta = (delta: unknown): ClientFeaturesDelta => {
-  if (
-    typeof delta === 'object' &&
-    delta !== null &&
-    'events' in delta &&
-    Array.isArray(delta.events)
-  ) {
-    return delta as ClientFeaturesDelta;
+export const parseApiResponse = (data: unknown): ApiResponse => {
+  if (typeof data !== 'object' || data === null) {
+    throw new Error(`Invalid API response: ${JSON.stringify(data, null, 2)}`);
   }
-  throw new Error(`Invalid delta response: ${JSON.stringify(delta, null, 2)}`);
+  if ('events' in data && Array.isArray(data.events)) {
+    return { ...data, type: 'delta' } as ClientFeaturesDelta & { type: 'delta' };
+  } else if ('features' in data && Array.isArray(data.features)) {
+    return { ...data, type: 'full' } as ClientFeaturesResponse & { type: 'full' };
+  }
+  throw new Error(
+    `Client features was neither a delta nor a full response: ${JSON.stringify(data, null, 2)}`,
+  );
 };
 
 export type DeltaEvent =

src/repository/index.ts

@@ -1,10 +1,11 @@
 import { EventEmitter } from 'node:events';
 import { UnleashEvents } from '../events';
-import type {
-  ApiResponse,
-  ClientFeaturesResponse,
-  EnhancedFeatureInterface,
-  FeatureInterface,
+import {
+  type ApiResponse,
+  type ClientFeaturesResponse,
+  type EnhancedFeatureInterface,
+  type FeatureInterface,
+  parseApiResponse,
 } from '../feature';
 import type { CustomHeaders, CustomHeadersFunction } from '../headers';
 import type { HttpOptions } from '../http-options';
@@ -232,47 +233,50 @@ export default class Repository extends EventEmitter implements EventEmitter {
   }
 
   private applyFeatureResponse(response: ApiResponse): void {
-    if ('events' in response) {
-      response.events.forEach((event) => {
-        switch (event.type) {
-          case 'feature-updated': {
-            this.data[event.feature.name] = event.feature;
-            break;
-          }
-          case 'feature-removed': {
-            delete this.data[event.featureName];
-            break;
-          }
-          case 'segment-updated': {
-            this.segments.set(event.segment.id, event.segment);
-            break;
-          }
-          case 'segment-removed': {
-            this.segments.delete(event.segmentId);
-            break;
-          }
-          case 'hydration': {
-            this.data = this.convertToMap(event.features);
-            this.segments = this.createSegmentLookup(event.segments);
-            break;
+    switch (response.type) {
+      case 'delta': {
+        response.events.forEach((event) => {
+          switch (event.type) {
+            case 'feature-updated': {
+              this.data[event.feature.name] = event.feature;
+              break;
+            }
+            case 'feature-removed': {
+              delete this.data[event.featureName];
+              break;
+            }
+            case 'segment-updated': {
+              this.segments.set(event.segment.id, event.segment);
+              break;
+            }
+            case 'segment-removed': {
+              this.segments.delete(event.segmentId);
+              break;
+            }
+            case 'hydration': {
+              this.data = this.convertToMap(event.features);
+              this.segments = this.createSegmentLookup(event.segments);
+              break;
+            }
+            default: {
+              this.emit(
+                UnleashEvents.Warn,
+                `Unknown event type received, this may or may not cause features to evaluate incorrectly: ${JSON.stringify(event)}`,
+              );
+              break;
+            }
           }
-          default: {
-            this.emit(
-              UnleashEvents.Warn,
-              `Unknown event type received, this may or may not cause features to evaluate incorrectly: ${JSON.stringify(event)}`,
-            );
-            break;
-          }
-        }
-      });
-    } else if ('features' in response) {
-      this.data = this.convertToMap(response.features);
-      this.segments = this.createSegmentLookup(response.segments);
-    } else {
-      this.emit(
-        UnleashEvents.Warn,
-        `Unknown response when applying feature response: ${JSON.stringify(response)}`,
-      );
+        });
+        break;
+      }
+      case 'full': {
+        this.data = this.convertToMap(response.features);
+        this.segments = this.createSegmentLookup(response.segments);
+        break;
+      }
+      default: {
+        assertNever(response);
+      }
     }
   }
 
@@ -290,7 +294,7 @@ export default class Repository extends EventEmitter implements EventEmitter {
       }
 
       if (content && this.notEmpty(content)) {
-        await this.save(content, false);
+        await this.save(parseApiResponse(content), false);
       }
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : 'Unknown error';
@@ -302,17 +306,16 @@ Message: ${message}`,
     }
   }
 
-  private convertToMap(features: FeatureInterface[]): FeatureToggleData {
-    const obj = (features || []).reduce(
-      (o: { [s: string]: FeatureInterface }, feature: FeatureInterface) => {
-        this.validateFeature(feature);
-        o[feature.name] = feature;
-        return o;
-      },
-      {} as { [s: string]: FeatureInterface },
-    );
-
-    return obj;
+  private convertToMap(features: FeatureInterface[] | undefined | null): FeatureToggleData {
+    const result: FeatureToggleData = {};
+    if (!features?.length) return {};
+
+    for (const feature of features) {
+      this.validateFeature(feature);
+      result[feature.name] = feature;
+    }
+
+    return result;
   }
 
   stop() {
@@ -373,3 +376,7 @@ Message: ${message}`,
     });
   };
 }
+
+const assertNever = (value: never): never => {
+  throw new Error(`Unexpected value: ${JSON.stringify(value)}`);
+};

src/repository/polling-fetcher.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { UnleashEvents } from '../events';
+import { parseApiResponse } from '../feature';
 import { get } from '../request';
 import type { TagFilter } from '../tags';
 import getUrl from '../url-utils';
@@ -165,7 +166,7 @@ export class PollingFetcher extends EventEmitter implements FetcherInterface {
             await this.options.onModeChange('streaming');
             return;
           }
-          await this.options.onSave(data, true);
+          await this.options.onSave(parseApiResponse(data), true);
         } catch (err) {
           this.emit(UnleashEvents.Error, err);
         }

src/repository/streaming-fetcher.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { EventSource } from '../event-source';
 import { UnleashEvents } from '../events';
-import { parseClientFeaturesDelta } from '../feature';
+import { parseApiResponse } from '../feature';
 import { buildHeaders } from '../request';
 import { resolveUrl } from '../url-utils';
 import type { FetcherInterface, StreamingFetchingOptions } from './fetcher';
@@ -127,7 +127,7 @@ export class StreamingFetcher extends EventEmitter implements FetcherInterface {
 
   private async handleFlagsFromStream(event: { data: string }) {
     try {
-      const data = parseClientFeaturesDelta(JSON.parse(event.data));
+      const data = parseApiResponse(JSON.parse(event.data));
       await this.onSave(data, true);
     } catch (err) {
       const errorMessage =