initial waitForInit implementation

Author: enver-bisevac

README.md

@@ -5,6 +5,7 @@
 [![APLv2][license-badge]][license]
 
 # Before you Begin
+
 Harness Feature Flags (FF) is a feature management solution that enables users to change the software’s functionality, without deploying new code. FF uses feature flags to hide code or behaviours without having to ship new versions of the software. A feature flag is like a powerful if statement.
 
 For more information, see https://harness.io/products/feature-flags/
@@ -17,7 +18,7 @@ To sign up, https://app.harness.io/auth/#/signup/
 
 ### Setup
 
-```npm install @harness/ff-nodejs-server-sdk```
+`npm install @harness/ff-nodejs-server-sdk`
 
 ### Import the package (CommonJS)
 
@@ -34,18 +35,21 @@ import { Client } from 'ff-nodejs-server-sdk';
 ### Initialize
 
 This is the most simple way to initialize SDK using only a server type key
+
 ```
 const client = new Client('your server type SDK key');
 ```
 
 Advanced initialization can be done using options
+
 ```
 const client = new Client('your server type SDK key', {
   enableStream: false
 });
 ```
 
 ### Define a target
+
 ```
 const target = {
   identifier: 'harness',
@@ -55,21 +59,40 @@ const target = {
 ```
 
 ### Evaluate the flag with default value set to false
+
 ```typescript
 const value = await client.boolVariation('test', target, false);
 ```
 
 ### Shutting down SDK
+
 ```
 client.close();
 ```
 
 ### Avaialable public methods
+
 ```typescript
-function boolVariation(identifier: string, target: Target, defaultValue = true): Promise<boolean>;
-function stringVariation(identifier, target: Target, defaultValue = ''): Promise<string>;
-function numberVariation(identifier, target: Target, defaultValue = 1.0): Promise<number>;
-function jsonVariation(identifier, target: Target, defaultValue = {}): Promise<Record<string, unknown>>;
+function boolVariation(
+  identifier: string,
+  target: Target,
+  defaultValue = true,
+): Promise<boolean>;
+function stringVariation(
+  identifier,
+  target: Target,
+  defaultValue = '',
+): Promise<string>;
+function numberVariation(
+  identifier,
+  target: Target,
+  defaultValue = 1.0,
+): Promise<number>;
+function jsonVariation(
+  identifier,
+  target: Target,
+  defaultValue = {},
+): Promise<Record<string, unknown>>;
 function close();
 ```
 
@@ -107,6 +130,32 @@ setInterval(async() => {
     console.log("Evaluation for flag test and target none: ", value);
 }, 10000);
 ```
+
+## Wait for initialization example
+
+```
+const { Client } = require('ff-nodejs-server-sdk');
+
+console.log('Starting application');
+const client = new Client('1c100d25-4c3f-487b-b198-3b3d01df5794');
+client
+  .waitForInitialization()
+  .then(() => {
+    setInterval(async () => {
+      const target = {
+        identifier: 'harness',
+      };
+      const value = await client.boolVariation('test', target, false);
+      console.log('Evaluation for flag test and target: ', value, target);
+    }, 10000);
+
+    console.log('Application started');
+  })
+  .catch((error) => {
+    console.log('Error', error);
+  });
+```
+
 ## License
 
 Licensed under the APLv2.

example/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ff-nodejs-server-sdk",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Feature flags SDK for NodeJS environments",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package.json

@@ -2,20 +2,35 @@ import * as events from 'events';
 import jwt_decode from 'jwt-decode';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
-import { Claims, Options, Target } from './types';
+import { Claims, Options, StreamEvent, Target } from './types';
 import { Configuration, ClientApi, FeatureConfig, Variation } from './openapi';
 import { VERSION } from './version';
-import { PollingProcessor } from './polling';
+import { PollerEvent, PollingProcessor } from './polling';
 import { StreamProcessor } from './streaming';
 import { Evaluator } from './evaluator';
 import { defaultOptions } from './constants';
 import { Repository, StorageRepository } from './repository';
-import { MetricsProcessor, MetricsProcessorInterface } from './metrics';
+import {
+  MetricEvent,
+  MetricsProcessor,
+  MetricsProcessorInterface,
+} from './metrics';
 
 axios.defaults.timeout = 30000;
 axiosRetry(axios, { retries: 3, retryDelay: axiosRetry.exponentialDelay });
 const log = defaultOptions.logger;
 
+enum Processor {
+  POLL,
+  STREAM,
+  METRICS,
+}
+
+export enum ClientEvent {
+  READY = 'ready',
+  FAILED = 'failed',
+  CHANGED = 'changed',
+}
 export default class Client {
   private evaluator: Evaluator;
   private repository: Repository;
@@ -30,6 +45,12 @@ export default class Client {
   private pollProcessor: PollingProcessor;
   private streamProcessor: StreamProcessor;
   private metricsProcessor: MetricsProcessorInterface;
+  private initialized = false;
+  private failure = false;
+  private waitForInitialize: Promise<Client>;
+  private pollerReady = false;
+  private streamReady = false;
+  private metricReady = false;
 
   constructor(sdkKey: string, options: Options = {}) {
     this.sdkKey = sdkKey;
@@ -54,9 +75,47 @@ export default class Client {
     );
     this.evaluator = new Evaluator(this.repository);
     this.api = new ClientApi(this.configuration);
+    this.processEvents();
     this.run();
   }
 
+  private processEvents(): void {
+    this.eventBus.on(PollerEvent.READY, () => {
+      this.initialize(Processor.POLL);
+    });
+
+    this.eventBus.on(PollerEvent.ERROR, () => {
+      this.failure = true;
+      this.eventBus.emit(ClientEvent.FAILED);
+    });
+
+    this.eventBus.on(StreamEvent.READY, () => {
+      this.initialize(Processor.STREAM);
+    });
+
+    this.eventBus.on(StreamEvent.ERROR, () => {
+      this.failure = true;
+      this.eventBus.emit(ClientEvent.FAILED);
+    });
+
+    this.eventBus.on(MetricEvent.READY, () => {
+      this.initialize(Processor.METRICS);
+    });
+
+    this.eventBus.on(MetricEvent.ERROR, () => {
+      this.failure = true;
+      this.eventBus.emit(ClientEvent.FAILED);
+    });
+
+    this.eventBus.on(StreamEvent.CONNECTED, () => {
+      this.pollProcessor.stop();
+    });
+
+    this.eventBus.on(StreamEvent.DISCONNECTED, () => {
+      this.pollProcessor.start();
+    });
+  }
+
   private async authenticate(): Promise<void> {
     try {
       const response = await this.api.authenticate({
@@ -70,10 +129,63 @@ export default class Client {
       this.environment = decoded.environment;
       this.cluster = decoded.clusterIdentifier || '1';
     } catch (error) {
+      this.failure = true;
       console.error('Error while authenticating, err: ', error);
     }
   }
 
+  waitForInitialization(): Promise<Client> {
+    if (this.waitForInitialize) {
+      return this.waitForInitialize;
+    }
+
+    if (this.initialized) {
+      this.waitForInitialize = Promise.resolve(this);
+    } else if (this.failure) {
+      this.waitForInitialize = Promise.reject(this.failure);
+    } else {
+      this.waitForInitialize = new Promise((resolve, reject) => {
+        this.eventBus.once(ClientEvent.READY, () => {
+          resolve(this);
+        });
+        this.eventBus.once(ClientEvent.FAILED, reject);
+      });
+    }
+    return this.waitForInitialize;
+  }
+
+  private initialize(processor: Processor): void {
+    switch (processor) {
+      case Processor.POLL:
+        this.pollerReady = true;
+        log.debug('PollingProcessor ready');
+        break;
+      case Processor.STREAM:
+        this.streamReady = true;
+        log.debug('StreamingProcessor ready');
+        break;
+      case Processor.METRICS:
+        this.metricReady = true;
+        log.debug('MetricsProcessor ready');
+        break;
+    }
+
+    if (this.options.enableStream && !this.streamReady) {
+      return;
+    }
+
+    if (this.options.enableAnalytics && !this.metricReady) {
+      return;
+    }
+
+    if (!this.pollerReady) {
+      return;
+    }
+
+    this.initialized = true;
+    this.eventBus.emit(ClientEvent.READY);
+  }
+
   private async run(): Promise<void> {
     await this.authenticate();
 
@@ -108,6 +220,7 @@ export default class Client {
         this.cluster,
         this.configuration,
         this.options,
+        this.eventBus,
       );
       this.metricsProcessor.start();
     }

src/client.ts

@@ -1,4 +1,4 @@
-import Client from './client';
+import Client, { ClientEvent } from './client';
 import LRU from 'lru-cache';
 import { Options, Target } from './types';
 import { Logger } from './log';
@@ -7,6 +7,7 @@ import { FileStore } from './store';
 
 export {
   Client,
+  ClientEvent,
   Options,
   Target,
   AsyncKeyValueStore,
@@ -22,6 +23,9 @@ export default {
       this.instance = new Client(sdkKey, options);
     }
   },
+  waitForInitialization: function (): Promise<Client> {
+    return this.instance.waitForInitialization();
+  },
   boolVariation: function (
     identifier: string,
     target: Target,

src/index.ts

@@ -1,3 +1,4 @@
+import * as events from 'events';
 import {
   defaultOptions,
   FEATURE_IDENTIFIER_ATTRIBUTE,
@@ -27,6 +28,11 @@ import { VERSION } from './version';
 
 const log = defaultOptions.logger;
 
+export enum MetricEvent {
+  READY = 'metrics_ready',
+  ERROR = 'metrics_error',
+}
+
 interface AnalyticsEvent {
   target: Target;
   featureConfig: FeatureConfig;
@@ -49,6 +55,7 @@ export const MetricsProcessor = (
   cluster = '1',
   conf: Configuration,
   options: Options,
+  eventBus: events.EventEmitter,
 ): MetricsProcessorInterface => {
   const data: Map<string, AnalyticsEvent> = new Map<string, AnalyticsEvent>();
   let syncInterval: NodeJS.Timeout;
@@ -202,6 +209,7 @@ export const MetricsProcessor = (
       options.eventsSyncInterval,
     );
     syncInterval = setInterval(_send, options.eventsSyncInterval);
+    eventBus.emit(MetricEvent.READY);
   };
 
   const close = (): void => {