@featbit/openfeature-provider-node-server 1.0.0

package/tests/FbProvider.test.ts

@@ -0,0 +1,294 @@
+import { FbProvider } from "../src";
+import { Client, ErrorCode, OpenFeature, ProviderEvents, ProviderStatus } from "@openfeature/server-sdk";
+import { IClientContext, IFbClient, integrations, ReasonKinds, IFallthrough, IStore } from "@featbit/node-server-sdk";
+import { translateContext } from "../src/translateContext";
+
+it('can be initialized', async () => {
+  const logger = new integrations.TestLogger();
+  const provider = new FbProvider({ sdkKey: 'sdk-key', offline: true, logger });
+  await provider.initialize({});
+
+  expect(provider.status).toEqual(ProviderStatus.READY);
+  expect(logger.logs.length).toEqual(2);
+  expect(logger.logs).toEqual(['Offline mode enabled. No data synchronization with the FeatBit server will occur.', 'FbClient started successfully.']);
+  await provider.onClose();
+});
+
+it('can fail to initialize client', async () => {
+  const logger = new integrations.TestLogger();
+  const provider = new FbProvider({
+    sdkKey: 'sdk-key',
+    logger,
+    streamingUri: 'ws://localhost:6001',
+    eventsUri: 'http://localhost:6001',
+    dataSynchronizer: (
+      clientContext: IClientContext,
+      store: IStore,
+      dataSourceUpdates: any,
+      initSuccessHandler: VoidFunction,
+      errorHandler?: (e: Error) => void,
+    ) => ({
+      start: () => {
+        setTimeout(() => errorHandler?.({ code: 401 } as any), 20);
+      },
+    })
+  });
+  try {
+    await provider.initialize({});
+  } catch (e) {
+    expect((e as Error).message).toEqual('Authentication failed. Double check your SDK key.');
+  }
+  expect(provider.status).toEqual(ProviderStatus.ERROR);
+});
+
+it('emits events for flag changes', async () => {
+  const logger = new integrations.TestLogger();
+  const td = new integrations.TestData();
+  const provider = new FbProvider( {
+    sdkKey: 'sdk-key',
+    logger,
+    dataSynchronizer: td.getFactory(),
+  });
+  let count = 0;
+  provider.events.addHandler(ProviderEvents.ConfigurationChanged, (eventDetail) => {
+    expect(eventDetail?.flagsChanged).toEqual(['flagA']);
+    count += 1;
+  });
+
+  const fallthrough: IFallthrough = {
+    dispatchKey: "keyId",
+    includedInExpt: true,
+    variations: [
+      {
+        id: "trueId",
+        exptRollout: 1,
+        rollout: [0, 1]
+      }
+    ]
+  }
+
+  const flag = new integrations.FlagBuilder()
+    .key('flagA')
+    .isEnabled(true)
+    .disabledVariationId('falseId')
+    .fallthrough(fallthrough)
+    .variations([{id: 'trueId', value: 'true'}, {id: 'falseId', value: 'false'}])
+    .version(1)
+    .build();
+
+  await td.update(flag);
+  expect(await provider.getClient()
+    .stringVariation('flagA', { key: 'test-key' }, 'false'))
+    .toEqual('true');
+  expect(count).toEqual(1);
+  await provider.onClose();
+});
+
+describe('given a mock FbClient', () => {
+  const logger: integrations.TestLogger = new integrations.TestLogger();
+  let provider: FbProvider;
+  let fbClient: IFbClient;
+  let openFeatureClient: Client;
+  const basicContext = { targetingKey: 'the-key' };
+  const testFlagKey = 'a-key';
+  let testFlagBuilder;
+
+  const td = new integrations.TestData();
+  const factory = td.getFactory();
+
+  beforeEach(() => {
+    testFlagBuilder = new integrations.FlagBuilder()
+      .key(testFlagKey)
+      .disabledVariationId('invalidId')
+      .fallthrough({
+        dispatchKey: "keyId",
+        includedInExpt: true,
+        variations: [
+          {
+            id: "trueId",
+            exptRollout: 1,
+            rollout: [0, 1]
+          }
+        ]
+      })
+      .targetUsers([{keyIds: [basicContext.targetingKey], variationId: 'trueId'}])
+      .variations([{id: 'trueId', value: 'true'}, {id: 'falseId', value: 'false'}, {id: 'invalidId', value: 'badness'}])
+      .version(1);
+
+    provider = new FbProvider({
+      sdkKey: 'sdk-key',
+      logger,
+      streamingUri: 'ws://localhost:5100',
+      eventsUri: 'http://localhost:5100',
+      dataSynchronizer: factory,
+    });
+
+    fbClient = provider.getClient();
+    OpenFeature.setProvider(provider);
+    openFeatureClient = OpenFeature.getClient();
+    logger.reset();
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  })
+
+  afterAll(async () => {
+    await provider.onClose();
+  });
+  // String variations
+  it('calls the client correctly for string variations', async () => {
+    fbClient.evaluateCore<string> = jest.fn( () => ({
+      kind: ReasonKinds.Off,
+      reason: '',
+      value: 'some value'
+    }));
+    await openFeatureClient.getStringDetails(testFlagKey, 'default', basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), 'default', expect.anything());
+    jest.clearAllMocks();
+    await openFeatureClient.getStringValue(testFlagKey, 'default', basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), 'default', expect.anything());
+  });
+
+  it('handles correct return types for string variations', async () => {
+    await td.update(testFlagBuilder.isEnabled(true).build());
+    const res = await openFeatureClient.getStringDetails(testFlagKey, 'default', basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: 'true',
+      reason: ReasonKinds.TargetMatch,
+    });
+  });
+
+  // Boolean variations
+  it('calls the client correctly for boolean variations', async () => {
+    fbClient.evaluateCore<boolean> = jest.fn( () => ({
+      kind: ReasonKinds.Off,
+      reason: '',
+      value: true
+    }));
+    await openFeatureClient.getBooleanDetails(testFlagKey, false, basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), false, expect.anything());
+    jest.clearAllMocks();
+    await openFeatureClient.getBooleanValue(testFlagKey, false, basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), false, expect.anything());
+  });
+
+  it('handles correct return types for boolean variations', async () => {
+    await td.update(testFlagBuilder.isEnabled(true).build());
+    const res = await openFeatureClient.getBooleanDetails(testFlagKey, false, basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: true,
+      reason: ReasonKinds.TargetMatch,
+    });
+  });
+
+  it('handles incorrect return types for boolean variations', async () => {
+    await td.update(testFlagBuilder.isEnabled(false).build());
+    const res = await openFeatureClient.getBooleanDetails(testFlagKey, false, basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: false,
+      reason: 'ERROR',
+      errorCode: 'TYPE_MISMATCH',
+    });
+  });
+
+  // Numeric variations
+  it('calls the client correctly for numeric variations', async () => {
+    fbClient.evaluateCore<number> = jest.fn( () => ({
+      kind: ReasonKinds.Off,
+      reason: '',
+      value: 1
+    }));
+    await openFeatureClient.getNumberDetails(testFlagKey, 0, basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), 0, expect.anything());
+    jest.clearAllMocks();
+    await openFeatureClient.getNumberValue(testFlagKey, 0, basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), 0, expect.anything());
+  });
+
+  it('handles correct return types for numeric variations', async () => {
+    await td.update(testFlagBuilder.variations([{id: 'invalidId', value: '1'}]).isEnabled(false).build());
+    const res = await openFeatureClient.getNumberDetails(testFlagKey, 0, basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: 1,
+      reason: ReasonKinds.Off
+    });
+  });
+
+  it('handles incorrect return types for numeric variations', async () => {
+    await td.update(testFlagBuilder.isEnabled(true).build());
+    const res = await openFeatureClient.getNumberDetails(testFlagKey, 0, basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: 0,
+      reason: 'ERROR',
+      errorCode: 'TYPE_MISMATCH',
+    });
+  });
+
+  // JSON variations
+  it('calls the client correctly for object variations', async () => {
+    fbClient.evaluateCore<any> = jest.fn( () => ({
+      kind: ReasonKinds.Off,
+      reason: '',
+      value: { some: 'value' }
+    }));
+    await openFeatureClient.getObjectDetails(testFlagKey, {}, basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), {}, expect.anything());
+    jest.clearAllMocks();
+    await openFeatureClient.getObjectValue(testFlagKey, {}, basicContext);
+    expect(fbClient.evaluateCore)
+      .toHaveBeenCalledWith(testFlagKey, translateContext(logger, basicContext), {}, expect.anything());
+  });
+
+  it('handles correct return types for object variations', async () => {
+    await td.update(testFlagBuilder.variations([{id: 'invalidId', value: '{"some": "value"}'}]).isEnabled(false).build());
+    const res = await openFeatureClient.getObjectDetails(testFlagKey, {}, basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: { some: 'value' },
+      reason: ReasonKinds.Off
+    });
+  });
+
+  it('handles incorrect return types for object variations', async () => {
+    await td.update(testFlagBuilder.isEnabled(false).build());
+    const res = await openFeatureClient.getObjectDetails(testFlagKey, {}, basicContext);
+    expect(res).toMatchObject({
+      flagKey: testFlagKey,
+      value: {},
+      reason: 'ERROR',
+      errorCode: 'TYPE_MISMATCH',
+    });
+  });
+
+  it('not existing flag', async () => {
+    const flagKey = 'not_existing_flag';
+    const res = await openFeatureClient.getObjectDetails(flagKey, {}, basicContext);
+    expect(res).toMatchObject({
+      flagKey,
+      value: {},
+      reason: 'ERROR',
+      errorCode:  ErrorCode.FLAG_NOT_FOUND,
+    });
+  });
+
+  it('logs information about missing keys', async () => {
+    await openFeatureClient.getObjectDetails(testFlagKey, {}, {});
+    expect(logger.logs[0]).toEqual("The EvaluationContext must contain either a 'targetingKey' "
+      + "or a 'key' and the type must be a string.");
+  });
+});
+
+

package/tests/SafeLogger.test.ts

@@ -0,0 +1,36 @@
+import SafeLogger from "../src/SafeLogger";
+import { BasicLogger, ILogger } from "@featbit/node-server-sdk";
+
+it('throws when constructed with an invalid logger', () => {
+  expect(
+    () => new SafeLogger({} as ILogger, new BasicLogger({})),
+  ).toThrow();
+});
+
+describe('given a logger that throws in logs', () => {
+  const strings: string[] = [];
+  const logger = new SafeLogger({
+    info: () => { throw new Error('info'); },
+    debug: () => { throw new Error('info'); },
+    warn: () => { throw new Error('info'); },
+    error: () => { throw new Error('info'); },
+  }, new BasicLogger({
+    level: 'debug',
+    destination: (...args: any) => {
+      strings.push(args.join(' '));
+    },
+  }));
+
+  it('uses the fallback logger', () => {
+    logger.debug('a');
+    logger.info('b');
+    logger.warn('c');
+    logger.error('d');
+    expect(strings).toEqual([
+      'debug: [FeatBit] a',
+      'info: [FeatBit] b',
+      'warn: [FeatBit] c',
+      'error: [FeatBit] d',
+    ]);
+  });
+});

package/tests/TestLogger.ts

@@ -0,0 +1,26 @@
+// import { ILogger } from "@featbit/node-server-sdk";
+//
+//
+// export default class TestLogger implements ILogger {
+//   public logs: string[] = [];
+//
+//   error(...args: any[]): void {
+//     this.logs.push(args.join(' '));
+//   }
+//
+//   warn(...args: any[]): void {
+//     this.logs.push(args.join(' '));
+//   }
+//
+//   info(...args: any[]): void {
+//     this.logs.push(args.join(' '));
+//   }
+//
+//   debug(...args: any[]): void {
+//     this.logs.push(args.join(' '));
+//   }
+//
+//   reset() {
+//     this.logs = [];
+//   }
+// }

package/tests/translateContext.test.ts

@@ -0,0 +1,102 @@
+import { translateContext } from "../src/translateContext";
+import { integrations } from "@featbit/node-server-sdk";
+
+const testLogger = new integrations.TestLogger();
+it('Uses the targetingKey as the user key', () => {
+  expect(translateContext(testLogger, { targetingKey: 'the-key' })).toEqual({ key: 'the-key', name: '', customizedProperties: [] });
+});
+
+it('Uses the name as the user name', () => {
+  expect(translateContext(testLogger, { name: 'the-key' })).toEqual({ key: '', name: 'the-key', customizedProperties: [] });
+});
+
+it('gives targetingKey precedence over key', () => {
+  expect(translateContext(
+    testLogger,
+    { targetingKey: 'target-key', key: 'key-key' },
+  )).toEqual({
+    key: 'target-key',
+    name: '',
+    customizedProperties: []
+  });
+});
+
+describe.each([
+  ['firstName', 'value3'],
+  ['lastName', 'value4'],
+  ['email', 'value5'],
+  ['avatar', 'value6'],
+  ['ip', 'value7'],
+  ['country', 'value8'],
+  ['anonymous', true],
+])('given custom attributes', (key, value) => {
+  it('accepts the custom attribute as customized property correctly', () => {
+    expect(translateContext(
+      testLogger,
+      { targetingKey: 'the-key', name: 'abc', [key]: value },
+    )).toEqual({
+      key: 'the-key',
+      name: 'abc',
+      customizedProperties: [{
+        name: key, value
+      }]
+    });
+  });
+});
+
+it('Accepts array custom as customized properties', () => {
+  const context = {
+    key: 'the-key',
+    custom: [{ name: 'custom1', value: 'value1' }, { name: 'custom2', value: 'value2' }]
+  };
+
+  expect(translateContext(
+    testLogger,
+    context,
+  )).toEqual({
+    key: 'the-key',
+    name: '',
+    customizedProperties: context.custom
+  });
+});
+
+it('Accepts object custom as customized properties', () => {
+  const context = {
+    key: 'the-key',
+    custom: {
+      custom1: 'value1',
+      custom2: 'value2'
+    }
+  };
+
+  expect(translateContext(
+    testLogger,
+    context,
+  )).toEqual({
+    key: 'the-key',
+    name: '',
+    customizedProperties: [
+      {
+        name: 'custom1',
+        value: 'value1'
+      },
+      {
+        name: 'custom2',
+        value: 'value2'
+      }
+    ]
+  });
+});
+
+it.each(['key', 'targetingKey'])('handles key or targetingKey', (key) => {
+  expect(translateContext(
+    testLogger,
+    { [key]: 'the-key' },
+  )).toEqual({
+    key: 'the-key',
+    name: '',
+    customizedProperties: []
+  });
+});
+
+

package/tests/translateResult.test.ts

@@ -0,0 +1,51 @@
+import { translateResult } from "../src/translateResult";
+import { IEvalDetail, ReasonKinds } from "@featbit/node-server-sdk"
+import { ErrorCode, StandardResolutionReasons } from "@openfeature/server-sdk";
+
+it.each([
+  true,
+  'potato',
+  42,
+  { yes: 'no' },
+])('puts the value into the result.', (value) => {
+  const evalDetail: IEvalDetail<typeof value> = {
+    value,
+    kind: ReasonKinds.FallThrough,
+  }
+
+  expect(translateResult<typeof value>(evalDetail).value).toEqual(value);
+});
+
+it.each([
+  ReasonKinds.Off,
+  ReasonKinds.FallThrough,
+  ReasonKinds.TargetMatch,
+  ReasonKinds.RuleMatch
+])('populates the resolution reason with kind', (kind: ReasonKinds) => {
+  expect(translateResult<boolean>({
+    value: true,
+    kind
+  }).reason).toEqual(kind);
+});
+
+it.each([
+  [ReasonKinds.WrongType, ErrorCode.TYPE_MISMATCH],
+  [ReasonKinds.Error, ErrorCode.GENERAL],
+  [ReasonKinds.ClientNotReady, ErrorCode.PROVIDER_NOT_READY],
+])('populates the resolution reason with error', (kind: ReasonKinds, expectedErrorCode) => {
+  const result = translateResult<boolean>({
+    value: true,
+    kind
+  });
+
+  expect(result.reason).toEqual(StandardResolutionReasons.ERROR);
+  expect(result.errorCode).toEqual(expectedErrorCode);
+});
+
+it('does not populate the errorCode when there is not an error', () => {
+  const translated = translateResult<boolean>({
+    value: true,
+    kind: ReasonKinds.FallThrough,
+  });
+  expect(translated.errorCode).toBeUndefined();
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "include": ["src/**/*"],
+    "compilerOptions": {
+      "module": "commonjs",
+      "esModuleInterop": true,
+      "target": "es6",
+      "moduleResolution": "node",
+      "sourceMap": true,
+      "outDir": "dist",
+      "rootDir": "src",
+      "declaration": true,
+      "declarationMap": true // enables importers to jump to source
+    },
+    "lib": ["es2015"]
+  }