Add Node.js OpenFeature provider

[matthewelwell]

Add a Flagsmith provider for the OpenFeature JavaScript SDK here.

See here for a reference implementation in python.

[mdedys]

Not sure if this is being worked on but for my own usage I re-wrote the Python provider. Had to copy some types from the library as they are not exported but hope this helps:

import {
  Provider,
  ProviderMetadata,
  ResolutionDetails,
  EvaluationContext,
  JsonValue,
  ErrorCode,
  FlagValueType,
  FlagNotFoundError,
  ParseError,
  TypeMismatchError,
  Logger,
} from "@openfeature/server-sdk";
import { Flags, Flagsmith } from "flagsmith-nodejs";
import { FlagsmithProviderError } from "./exceptions";
// Also not exported from flagsmith-nodejs
import { BaseFlag } from "./types";

// This is not exported by flagsmith-nodejs, so we define it here
type IFlagsmithValue<T = string | number | boolean | null> = T;
type FlagsmithTraitValue = IFlagsmithValue;
type ITraitConfig = {
  value: FlagsmithTraitValue;
  transient?: boolean;
};
type FlagsmithTrait = Record<string, FlagsmithTraitValue | ITraitConfig>;

enum FlagType {
  BOOLEAN = "boolean",
  STRING = "string",
  NUMBER = "number",
  OBJECT = "object",
}

const BASIC_FLAG_TYPE_MAPPINGS = {
  [FlagType.BOOLEAN]: "boolean",
  [FlagType.STRING]: "string",
  [FlagType.NUMBER]: "number",
  [FlagType.OBJECT]: "object",
};

export default class FlagsmithOpenFeatureProvider implements Provider {
  readonly metadata: ProviderMetadata = {
    name: "Flagsmith OpenFeature Provider",
    version: "1.0.0",
  };

  readonly runOns = "server";

  private client: Flagsmith;
  private returnValueForDisabledFlags: boolean;
  private useFlagsmithDefaults: boolean;
  private useBooleanConfigValue: boolean;

  constructor(
    client: Flagsmith,
    returnValueForDisabledFlags: boolean,
    useFlagsmithDefaults: boolean,
    useBooleanConfigValue: boolean,
  ) {
    this.client = client;
    this.returnValueForDisabledFlags = returnValueForDisabledFlags;
    this.useFlagsmithDefaults = useFlagsmithDefaults;
    this.useBooleanConfigValue = useBooleanConfigValue;
  }

  private isValidTypeForFlag(value: any, flagType: FlagValueType): boolean {
    const requiredType = BASIC_FLAG_TYPE_MAPPINGS[flagType];
    if (!requiredType) return false;
    switch (flagType) {
      case FlagType.BOOLEAN:
        return typeof value === "boolean";
      case FlagType.STRING:
        return typeof value === "string";
      case FlagType.OBJECT:
        return typeof value === "object" && value !== null;
      case FlagType.NUMBER:
        return typeof value === "number";
      default:
        return typeof value === requiredType;
    }
  }

  private getFlags(evaluatonContext: EvaluationContext): Promise<Flags> {
    if (evaluatonContext?.targetingKey) {
      return this.client.getIdentityFlags(
        evaluatonContext.targetingKey,
        (evaluatonContext.traits as FlagsmithTrait | undefined) || {},
      );
    }
    return this.client.getEnvironmentFlags();
  }

  private async resolve(
    flagKey: string,
    flagType: FlagValueType,
    evaluationContext: EvaluationContext,
  ): Promise<ResolutionDetails<any>> {
    let flag: BaseFlag;
    try {
      const flags = await this.getFlags(evaluationContext);
      flag = flags.getFlag(flagKey);
    } catch (ex) {
      throw new FlagsmithProviderError(
        "An error occurred retrieving flags from Flagsmith client.",
        ErrorCode.GENERAL,
      );
    }

    if (flag.isDefault && !this.useFlagsmithDefaults) {
      throw new FlagNotFoundError(`Flag "${flagKey}" was not found.`);
    }

    if (flagType === FlagType.BOOLEAN && !this.useBooleanConfigValue) {
      return { value: flag.enabled };
    }

    if (!(this.returnValueForDisabledFlags || flag.enabled)) {
      throw new FlagsmithProviderError(
        `Flag "${flagKey}" is not enabled.`,
        ErrorCode.GENERAL,
      );
    }

    if (this.isValidTypeForFlag(flag.value, flagType)) {
      return { value: flag.value };
    } else if (flagType === FlagType.OBJECT && typeof flag.value === "string") {
      try {
        return { value: JSON.parse(flag.value) };
      } catch (error) {
        throw new ParseError(`Flag "${flagKey}" has an invalid object value.`);
      }
    }

    throw new TypeMismatchError(
      `Value for flag "${flagKey}" is not of type ${flagType}`,
    );
  }

  async resolveBooleanEvaluation(
    flagKey: string,
    _: boolean,
    context: EvaluationContext,
    __: Logger,
  ): Promise<ResolutionDetails<boolean>> {
    return this.resolve(flagKey, FlagType.BOOLEAN, context);
  }

  async resolveStringEvaluation(
    flagKey: string,
    _: string,
    context: EvaluationContext,
    __: Logger,
  ): Promise<ResolutionDetails<string>> {
    return this.resolve(flagKey, FlagType.STRING, context);
  }
  async resolveNumberEvaluation(
    flagKey: string,
    _: number,
    context: EvaluationContext,
    __: Logger,
  ): Promise<ResolutionDetails<number>> {
    return this.resolve(flagKey, FlagType.NUMBER, context);
  }
  async resolveObjectEvaluation<T extends JsonValue>(
    flagKey: string,
    _: T,
    context: EvaluationContext,
    __: Logger,
  ): Promise<ResolutionDetails<T>> {
    return this.resolve(flagKey, FlagType.OBJECT, context) as Promise<
      ResolutionDetails<T>
    >;
  }
}

[rolodato]

Thanks @mdedys! No news on the OpenFeature provider that I know of, but I created #188 to export the missing types.

[matthewelwell]

I think, once the above PR that @rolodato has linked is merged, we can tidy it up and submit this code as a PR to this repository. We're obviously happy to do so and take all the credit (😉) but if you'd like to submit the PR yourself @mdedys, let us know - and if you'd like any support doing so.

[mdedys]

I think, once the above PR that @rolodato has linked is merged, we can tidy it up and submit this code as a PR to this repository. We're obviously happy to do so and take all the credit (😉) but if you'd like to submit the PR yourself @mdedys, let us know - and if you'd like any support doing so.

You folks can take all the credit! Not sure if I have the time to set up a proper PR tbh.