NestJS

Installation

Add the OpenFeature SDK and the Tggl Provider to your project:

npm i @openfeature/nestjs-sdk openfeature-server-tggl-provider

Quick start

Configure the OpenFeatureModule with the TgglServerProvider in your application module:

import { Module } from '@nestjs/common';
import { OpenFeatureModule } from '@openfeature/nestjs-sdk';
import { TgglServerProvider } from 'openfeature-server-tggl-provider'
 
@Module({
  imports: [
    OpenFeatureModule.forRoot({
      defaultProvider: new TgglServerProvider('API_KEY'),
    }),
  ],
})
export class AppModule {}

You can now inject flag evaluation details into route handlers like so:

import { Controller, Get } from '@nestjs/common';
import { map, Observable } from 'rxjs';
import { BooleanFeatureFlag, EvaluationDetails } from '@openfeature/nestjs-sdk';
 
@Controller()
export class MyController {
  @Get('/welcome')
  public async welcome(
    @BooleanFeatureFlag({
      flagKey: 'my-feature',
      defaultValue: false,
    })
    feature: Observable<EvaluationDetails<boolean>>,
  ) {
    return feature.pipe(
      map(({ value }) =>
        value ? 'My feature is active!' : 'My feature is not active :(',
      ),
    );
  }
}

You can also inject the client to evaluate flags in your services:

import { Injectable } from '@nestjs/common';
import { OpenFeatureClient, Client } from '@openfeature/nestjs-sdk';
 
@Injectable()
export class MyService {
  constructor(
    @OpenFeatureClient() private client: Client
  ) {}
 
  public async getBoolean() {
    return await this.client.getBooleanValue('my-feature', false);
  }
}

Getting a flag's value

There are four methods to get a flag's value: getBooleanValue, getNumberValue, getStringValue, and getObjectValue. Those four methods return a Promise, but evaluation is done locally and no API call is performed.

Each method takes the flag's key as the first argument, a default value as the second argument, and an optional context object as the third argument.

await client.getBooleanValue('feat-a', false, { userId: 'foo' })
await client.getNumberValue('feat-b', 42, { userId: 'foo' })
await client.getStringValue('feat-c', 'foo', { userId: 'foo' })
await client.getObjectValue('feat-d', { custom: 'object' }, { userId: 'foo' })

The default value must be specified and will be returned if the flag is not found or if an error occurs.

Info

When calling either getBooleanValue, getNumberValue, or getStringValue, the value will be cast to the appropriate type. If you are unsure of the type of the flag, use getObjectValue to get the raw value which may be of any valid JSON value, including boolean, string, and number.

Polling for "live" updates

If you need your client to be up-to-date with the latest flag configuration, you can enable polling:

new TgglServerProvider('API_KEY', {
  pollingInterval: 5000
})

Here, the provider will poll the Tggl API every 5 seconds for updates. You can be notified when the configuration changes by listening to the ConfigurationChanged event:

OpenFeature.addHandler(ServerProviderEvents.ConfigurationChanged, () => {
  // Configuration has changed
})

This is a good time to recompute flags where you need a "live" value.

Using the Proxy

By default, the Provider talks directly to the Tggl API. If you are using the Tggl Proxy, you can specify the proxy URL when instantiating the provider:

new TgglServerProvider('API_KEY', {
  baseUrl: 'http://your-proxy-domain.com'
})

The /config and /report path will be appended to the baseUrl and both flags evaluation and reporting will go through the proxy. If your proxy is configured with custom paths, you can specify them:

new TgglServerProvider('API_KEY', {
  url: 'http://your-proxy-domain.com/custom-config',
  reporting: {
    url: 'http://your-proxy-domain.com/custom-report'
  }
})

Going further

Read the official OpenFeature SDK documentation for more information on how to use the SDK.

You can also have a look at Tggl's Node.js SDK documentation that is used under the hood by the TgglServerProvider.