#3 Implement in memory feature store and async wrapper.

server-sdk-common/__tests__/store/InMemoryFeatureStore.test.ts

@@ -0,0 +1,150 @@
+import AsyncStoreFacade from '../../src/store/AsyncStoreFacade';
+import InMemoryFeatureStore from '../../src/store/InMemoryFeatureStore';
+import VersionedDataKinds from '../../src/store/VersionedDataKinds';
+
+// To simplify testing the memory store will be wrapped with the async facade.
+// Writing the tests with callbacks would make them much more difficult to follow.
+
+describe('given an empty feature store and async facade', () => {
+  const store = new AsyncStoreFacade(new InMemoryFeatureStore());
+
+  it('can be initialized', async () => {
+    await store.init({});
+    const initialized = await store.initialized();
+    expect(initialized).toBeTruthy();
+  });
+});
+
+describe('given an initialized feature store', () => {
+  let featureStore: AsyncStoreFacade;
+  const feature1 = { key: 'foo', version: 10 };
+  const feature2 = { key: 'bar', version: 10 };
+
+  beforeEach(async () => {
+    featureStore = new AsyncStoreFacade(new InMemoryFeatureStore());
+    return featureStore.init({
+      [VersionedDataKinds.Features.namespace]: {
+        foo: feature1,
+        bar: feature2,
+      },
+      [VersionedDataKinds.Segments.namespace]: {},
+    });
+  });
+
+  it('gets an existing feature', async () => {
+    const feature = await featureStore.get(VersionedDataKinds.Features, 'foo');
+    expect(feature).toStrictEqual(feature1);
+  });
+
+  it('gets null for a feature that does not exist', async () => {
+    const feature = await featureStore.get(VersionedDataKinds.Features, 'unknown');
+    expect(feature).toBeNull();
+  });
+
+  it('gets all features', async () => {
+    const features = await featureStore.all(VersionedDataKinds.Features);
+    expect(features).toStrictEqual({
+      foo: feature1,
+      bar: feature2,
+    });
+  });
+
+  it('does not upsert an older version', async () => {
+    await featureStore.upsert(VersionedDataKinds.Features, {
+      ...feature1,
+      version: feature1.version - 1,
+    });
+    const feature = await featureStore.get(VersionedDataKinds.Features, 'foo');
+    expect(feature).toEqual(feature1);
+  });
+
+  it('does upsert a newer version', async () => {
+    const updatedFeature = {
+      ...feature1,
+      version: feature1.version + 1,
+    };
+    await featureStore.upsert(VersionedDataKinds.Features, updatedFeature);
+    const feature = await featureStore.get(VersionedDataKinds.Features, 'foo');
+    expect(feature).toEqual(updatedFeature);
+  });
+
+  it('does upsert a new feature', async () => {
+    const newFeature = {
+      key: 'new-feature',
+      version: feature1.version + 1,
+    };
+    await featureStore.upsert(VersionedDataKinds.Features, newFeature);
+    const feature = await featureStore.get(VersionedDataKinds.Features, newFeature.key);
+    expect(feature).toEqual(newFeature);
+  });
+
+  it('handles race conditions in upserts', async () => {
+    const ver1 = { key: feature1.key, version: feature1.version + 1 };
+    const ver2 = { key: feature1.key, version: feature1.version + 2 };
+
+    // Intentionally not awaiting these.
+    const p1 = featureStore.upsert(VersionedDataKinds.Features, ver1);
+    const p2 = featureStore.upsert(VersionedDataKinds.Features, ver2);
+
+    // Let them both finish.
+    await Promise.all([p2, p1]);
+
+    const feature = await featureStore.get(VersionedDataKinds.Features, feature1.key);
+    expect(feature).toEqual(ver2);
+  });
+
+  it('deletes with newer version', async () => {
+    featureStore.delete(VersionedDataKinds.Features, feature1.key, feature1.version + 1);
+    const feature = await featureStore.get(VersionedDataKinds.Features, feature1.key);
+    expect(feature).toBeNull();
+  });
+
+  it('does not delete with older version', async () => {
+    featureStore.delete(VersionedDataKinds.Features, feature1.key, feature1.version - 1);
+    const feature = await featureStore.get(VersionedDataKinds.Features, feature1.key);
+    expect(feature).toStrictEqual(feature1);
+  });
+
+  it('allows deleting an unknown feature', async () => {
+    featureStore.delete(VersionedDataKinds.Features, 'unknown', 10);
+    const feature = await featureStore.get(VersionedDataKinds.Features, 'unknown');
+    expect(feature).toBeNull();
+  });
+
+  it('does not upsert older version after delete', async () => {
+    const key = 'featureKey';
+    featureStore.delete(VersionedDataKinds.Features, key, 10);
+
+    featureStore.upsert(VersionedDataKinds.Features, {
+      key,
+      version: 9,
+    });
+    const feature = await featureStore.get(VersionedDataKinds.Features, key);
+    expect(feature).toBeNull();
+  });
+
+  it('does upsert newer version after delete', async () => {
+    const key = 'featureKey';
+    featureStore.delete(VersionedDataKinds.Features, key, 10);
+
+    featureStore.upsert(VersionedDataKinds.Features, {
+      key,
+      version: 11,
+    });
+    const feature = await featureStore.get(VersionedDataKinds.Features, key);
+    expect(feature).toStrictEqual({
+      key,
+      version: 11,
+    });
+  });
+
+  it('does upsert a new item of unknown kind', async () => {
+    const newPotato = {
+      key: 'new-feature',
+      version: 1,
+    };
+    await featureStore.upsert({namespace: 'potato'}, newPotato);
+    const feature = await featureStore.get({namespace: 'potato'}, newPotato.key);
+    expect(feature).toEqual(newPotato);
+  });
+});

server-sdk-common/src/api/subsystems/LDFeatureStore.ts

@@ -1,3 +1,32 @@
+import { DataKind } from '../interfaces';
+
+/**
+ * Represents an item which can be stored in the feature store.
+ */
+export interface LDFeatureStoreItem {
+  deleted?: boolean;
+  version: number;
+  // The actual data associated with the item.
+  [attribute: string]: any;
+}
+
+/**
+ * When upserting an item it must contain a key.
+ */
+export interface LDKeyedFeatureStoreItem extends LDFeatureStoreItem {
+  key: string;
+}
+
+/**
+ * Represents the storage for a single kind of data. e.g. 'flag' or 'segment'.
+ */
+export interface LDFeatureStoreKindData {[key: string]: LDFeatureStoreItem }
+
+/**
+ * Represents the storage for the full data store.
+ */
+export interface LDFeatureStoreDataStorage {[namespace: string]: LDFeatureStoreKindData }
+
 /**
  * Interface for a feature store component.
  *
@@ -30,7 +59,7 @@ export interface LDFeatureStore {
    *   Will be called with the retrieved entity, or null if not found. The actual type of the result
    *   value is [[interfaces.VersionedData]].
    */
-  get(kind: object, key: string, callback: (res: object) => void): void;
+  get(kind: DataKind, key: string, callback: (res: LDFeatureStoreItem | null) => void): void;
 
   /**
    * Get all entities from a collection.
@@ -46,7 +75,7 @@ export interface LDFeatureStore {
    *   Will be called with the resulting map. The actual type of the result value is
    *   `interfaces.KeyedItems<VersionedData>`.
    */
-  all(kind: object, callback: (res: object) => void): void;
+  all(kind: DataKind, callback: (res: LDFeatureStoreKindData) => void): void;
 
   /**
    * Initialize the store, overwriting any existing data.
@@ -59,7 +88,7 @@ export interface LDFeatureStore {
    * @param callback
    *   Will be called when the store has been initialized.
    */
-  init(allData: object, callback: () => void): void;
+  init(allData: LDFeatureStoreDataStorage, callback: () => void): void;
 
   /**
    * Delete an entity from the store.
@@ -83,7 +112,7 @@ export interface LDFeatureStore {
    * @param callback
    *   Will be called when the delete operation is complete.
    */
-  delete(kind: object, key: string, version: string, callback: () => void): void;
+  delete(kind: DataKind, key: string, version: number, callback: () => void): void;
 
   /**
    * Add an entity or update an existing entity.
@@ -101,7 +130,7 @@ export interface LDFeatureStore {
    * @param callback
    *   Will be called after the upsert operation is complete.
    */
-  upsert(kind: object, data: object, callback: () => void): void;
+  upsert(kind: DataKind, data: LDKeyedFeatureStoreItem, callback: () => void): void;
 
   /**
    * Tests whether the store is initialized.

server-sdk-common/src/store/AsyncStoreFacade.ts

@@ -0,0 +1,75 @@
+import { DataKind } from '../api/interfaces';
+import {
+  LDFeatureStore,
+  LDFeatureStoreDataStorage,
+  LDFeatureStoreItem,
+  LDFeatureStoreKindData,
+  LDKeyedFeatureStoreItem,
+} from '../api/subsystems';
+
+/**
+ * A basic wrapper to make async methods with callbacks into promises.
+ *
+ * @param method
+ * @returns A promisified version of the method.
+ */
+function promisify<T>(method: (callback: (val: T) => void) => void): Promise<T> {
+  return new Promise<T>((resolve) => {
+    method((val: T) => { resolve(val); });
+  });
+}
+
+/**
+ * Provides an async interface to a feature store.
+ *
+ * This allows for using a store using async/await instead of callbacks.
+ *
+ * @internal
+ */
+export default class AsyncStoreFacade {
+  private store: LDFeatureStore;
+
+  constructor(store: LDFeatureStore) {
+    this.store = store;
+  }
+
+  async get(kind: DataKind, key: string): Promise<LDFeatureStoreItem | null> {
+    return promisify((cb) => {
+      this.store.get(kind, key, cb);
+    });
+  }
+
+  async all(kind: DataKind): Promise<LDFeatureStoreKindData> {
+    return promisify((cb) => {
+      this.store.all(kind, cb);
+    });
+  }
+
+  async init(allData: LDFeatureStoreDataStorage): Promise<void> {
+    return promisify((cb) => {
+      this.store.init(allData, cb);
+    });
+  }
+
+  async delete(kind: DataKind, key: string, version: number): Promise<void> {
+    return promisify((cb) => {
+      this.store.delete(kind, key, version, cb);
+    });
+  }
+
+  async upsert(kind: DataKind, data: LDKeyedFeatureStoreItem): Promise<void> {
+    return promisify((cb) => {
+      this.store.upsert(kind, data, cb);
+    });
+  }
+
+  async initialized(): Promise<boolean> {
+    return promisify((cb) => {
+      this.store.initialized(cb);
+    });
+  }
+
+  close(): void {
+    this.store.close();
+  }
+}

server-sdk-common/src/store/InMemoryFeatureStore.ts

@@ -0,0 +1,91 @@
+import { DataKind } from '../api/interfaces';
+import {
+  LDFeatureStoreDataStorage,
+  LDKeyedFeatureStoreItem,
+  LDFeatureStore,
+  LDFeatureStoreKindData,
+  LDFeatureStoreItem,
+} from '../api/subsystems';
+
+/**
+ * Clone an object using JSON. This will not preserve
+ * non-JSON types (like functions).
+ * @param obj
+ * @returns A clone of the object.
+ */
+function clone(obj: any): any {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+export default class InMemoryFeatureStore implements LDFeatureStore {
+  private allData: LDFeatureStoreDataStorage = {};
+
+  private initCalled = false;
+
+  private addItem(kind: DataKind, key: string, item: LDFeatureStoreItem) {
+    let items = this.allData[kind.namespace];
+    if (!items) {
+      items = {};
+      this.allData[kind.namespace] = items;
+    }
+    if (Object.hasOwnProperty.call(items, key)) {
+      const old = items[key];
+      if (!old || old.version < item.version) {
+        items[key] = item;
+      }
+    } else {
+      items[key] = item;
+    }
+  }
+
+  get(kind: DataKind, key: string, callback: (res: LDFeatureStoreItem | null) => void): void {
+    const items = this.allData[kind.namespace];
+    if (items) {
+      if (Object.prototype.hasOwnProperty.call(items, key)) {
+        const item = items[key];
+        if (item && !item.deleted) {
+          return callback?.(item);
+        }
+      }
+    }
+    return callback?.(null);
+  }
+
+  all(kind: DataKind, callback: (res: LDFeatureStoreKindData) => void): void {
+    const result: LDFeatureStoreKindData = {};
+    const items = this.allData[kind.namespace] ?? {};
+    Object.entries(items).forEach(([key, item]) => {
+      if (item && !item.deleted) {
+        result[key] = item;
+      }
+    });
+    callback?.(result);
+  }
+
+  init(allData: LDFeatureStoreDataStorage, callback: () => void): void {
+    this.initCalled = true;
+    this.allData = allData as LDFeatureStoreDataStorage;
+    callback?.();
+  }
+
+  delete(kind: DataKind, key: string, version: number, callback: () => void): void {
+    const deletedItem = { version, deleted: true };
+    this.addItem(kind, key, deletedItem);
+    callback?.();
+  }
+
+  upsert(kind: DataKind, data: LDKeyedFeatureStoreItem, callback: () => void): void {
+    const item = clone(data);
+    this.addItem(kind, item.key, item);
+    callback?.();
+  }
+
+  initialized(callback: (isInitialized: boolean) => void): void {
+    return callback?.(this.initCalled);
+  }
+
+  /* eslint-disable class-methods-use-this */
+  close(): void {
+    // For the memory store this is a no-op.
+  }
+}