feat: use Nest.js SDK in backend

docker-compose.yaml

@@ -1,10 +1,10 @@
 version: '3.8'
 services:
   demo:
-    image: ghcr.io/open-feature/playground-app:v0.13.4 # x-release-please-version
-    # build:
-    #  dockerfile: ./packages/app/Dockerfile
-    #  context: .
+    # image: ghcr.io/open-feature/playground-app:v0.13.4 # x-release-please-version
+    build:
+     dockerfile: ./packages/app/Dockerfile
+     context: .
     ports:
       - '30000:30000'
     command:
@@ -46,10 +46,10 @@ services:
       - FLAGD_TLS_WEB
 
   fib-service:
-    image: ghcr.io/open-feature/playground-fib-service:v0.13.4 # x-release-please-version
-    # build:
-    #   dockerfile: ./packages/fibonacci-service/Dockerfile
-    #   context: .
+    # image: ghcr.io/open-feature/playground-fib-service:v0.13.4 # x-release-please-version
+    build:
+      dockerfile: ./packages/fibonacci-service/Dockerfile
+      context: .
     expose:
       - '30001'
     environment:

package.json

@@ -24,12 +24,12 @@
     "@nestjs/platform-express": "9.4.3",
     "@nestjs/serve-static": "^3.0.1",
     "@openfeature/env-var-provider": "^0.2.0",
-    "@openfeature/flagd-provider": "^0.9.0",
+    "@openfeature/flagd-provider": "^0.10.4",
     "@openfeature/flagd-web-provider": "^0.4.1",
     "@openfeature/go-feature-flag-provider": "^0.6.1",
+    "@openfeature/nestjs-sdk": "^0.0.4-experimental",
     "@openfeature/open-telemetry-hooks": "^0.3.0",
-    "@openfeature/server-sdk": "^1.7.5",
-    "@openfeature/web-sdk": "0.4.7",
+    "@openfeature/web-sdk": "0.4.10",
     "@opentelemetry/api": "^1.7.0",
     "@opentelemetry/auto-instrumentations-node": "^0.40.2",
     "@opentelemetry/core": "^1.18.1",

packages/app/src/app/app.module.ts

@@ -1,50 +1,25 @@
 import {HttpModule} from '@nestjs/axios';
-import {MiddlewareConsumer, Module, NestModule, Scope} from '@nestjs/common';
-import {REQUEST} from '@nestjs/core';
+import {ExecutionContext, Module} from '@nestjs/common';
 import {ServeStaticModule} from '@nestjs/serve-static';
-import {AsyncLocalStorageTransactionContext, LoggingHook, OpenFeatureLogger} from '@openfeature/extra';
-import { FlagMetadata, OpenFeature } from '@openfeature/server-sdk';
-import {MetricsHook, TracingHook as SpanEventBasedTracingHook} from '@openfeature/open-telemetry-hooks';
+import {LoggingHook, OpenFeatureLogger} from '@openfeature/extra';
+import {TracingHook as SpanEventBasedTracingHook, MetricsHook} from '@openfeature/open-telemetry-hooks';
 import {ProviderService} from '@openfeature/provider';
 import {Request} from 'express';
 import {Agent} from 'http';
 import {LoggerModule} from 'nestjs-pino';
 import {join} from 'path';
-import {OPENFEATURE_CLIENT, REQUEST_DATA} from './constants';
 import {FibonacciAsAServiceController} from './fibonacci-as-a-service.controller';
 import {FibonacciService} from './fibonacci/fibonacci.service';
 import {ProvidersController} from './providers.controller';
-import {TransactionContextMiddleware} from './transaction-context.middleware';
-import {RequestData} from './types';
 import {UtilsController} from './utils.controller';
-
-/**
- * Set a global logger for OpenFeature. This is logger will available in hooks.
- */
-OpenFeature.setLogger(new OpenFeatureLogger('OpenFeature'));
+import {EvaluationContext, FlagMetadata, OpenFeatureModule} from "@openfeature/nestjs-sdk";
 
 function attributeMapper(flagMetadata: FlagMetadata) {
   return {
-    ...('scope' in flagMetadata && { scope: flagMetadata.scope }),
+    ...('scope' in flagMetadata && {scope: flagMetadata.scope}),
   };
 }
 
-/**
- * Adding hooks to at the global level will ensure they always run
- * as part of a flag evaluation lifecycle.
- */
-OpenFeature.addHooks(
-  new LoggingHook(),
-  new SpanEventBasedTracingHook({attributeMapper}),
-  new MetricsHook({attributeMapper}));
-
-/**
- * The transaction context propagator is an experimental feature
- * that allows evaluation context to be set anywhere in a request
- * and have it automatically available during a flag evaluation.
- */
-OpenFeature.setTransactionContextPropagator(new AsyncLocalStorageTransactionContext());
-
 @Module({
   imports: [
     LoggerModule.forRoot({
@@ -59,53 +34,47 @@ OpenFeature.setTransactionContextPropagator(new AsyncLocalStorageTransactionCont
         transport:
           process.env['NODE' + '_ENV'] !== 'production'
             ? {
-                target: 'pino-pretty',
-                options: {
-                  hideObject: true,
-                },
-              }
+              target: 'pino-pretty',
+              options: {
+                hideObject: true,
+              },
+            }
             : undefined,
       },
     }),
     ServeStaticModule.forRoot({
       rootPath: join(__dirname, '..', 'ui'),
     }),
     HttpModule.register({
-      httpAgent: new Agent({ keepAlive: true }),
+      httpAgent: new Agent({keepAlive: true}),
     }),
-  ],
-  controllers: [FibonacciAsAServiceController, UtilsController, ProvidersController],
-  providers: [
-    FibonacciService,
-    ProviderService,
-    {
-      provide: OPENFEATURE_CLIENT,
-      useFactory: () => {
-        const client = OpenFeature.getClient('app');
-        return client;
-      },
-    },
-    {
-      provide: REQUEST_DATA,
-      useFactory: (req: Request): RequestData => {
+    OpenFeatureModule.forRoot({
+      // Set a global logger for OpenFeature. This is logger will available in hooks.
+      logger: new OpenFeatureLogger('OpenFeature'),
+      //Adding hooks to at the global level will ensure they always run as part of a flag evaluation lifecycle.
+      hooks: [new LoggingHook(), new SpanEventBasedTracingHook({attributeMapper}), new MetricsHook({attributeMapper})],
+      // This context will be used for all flag evaluations in the callstack
+      contextFactory: async (context: ExecutionContext): Promise<EvaluationContext> => {
+        const req = await context.switchToHttp().getRequest<Request>()
         const authHeaderValue = req.header('Authorization') || 'anonymous';
         const userAgent = req.header('user-agent');
         return {
+          ts: new Date().getTime(),
           ip: (req.headers['x-forwarded-for'] as string) || (req.socket.remoteAddress as string),
           email: authHeaderValue,
           method: req.method,
           path: req.path,
-          ...(userAgent && { userAgent }),
+          ...(userAgent && {userAgent}),
           targetingKey: authHeaderValue,
         };
       },
-      scope: Scope.REQUEST,
-      inject: [REQUEST],
-    },
+    })
+  ],
+  controllers: [FibonacciAsAServiceController, UtilsController, ProvidersController],
+  providers: [
+    FibonacciService,
+    ProviderService,
   ],
 })
-export class AppModule implements NestModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(TransactionContextMiddleware).forRoutes(FibonacciAsAServiceController);
-  }
+export class AppModule {
 }

packages/app/src/app/fibonacci/fibonacci.service.ts

@@ -1,15 +1,15 @@
-import { HttpService } from '@nestjs/axios';
-import { Inject, Injectable } from '@nestjs/common';
-import { fibonacci } from '@openfeature/fibonacci';
-import { Client } from '@openfeature/server-sdk';
-import { OPENFEATURE_CLIENT } from '../constants';
-import { lastValueFrom, map } from 'rxjs';
+import {HttpService} from '@nestjs/axios';
+import {Injectable} from '@nestjs/common';
+import {fibonacci} from '@openfeature/fibonacci';
+import {lastValueFrom, map} from 'rxjs';
+import {Client, FeatureClient} from "@openfeature/nestjs-sdk";
 
 @Injectable()
 export class FibonacciService {
   private readonly FIB_SERVICE_URL = process.env.FIB_SERVICE_URL || 'http://localhost:30001';
 
-  constructor(private readonly httpService: HttpService, @Inject(OPENFEATURE_CLIENT) private client: Client) {}
+  constructor(private readonly httpService: HttpService, @FeatureClient() private client: Client) {
+  }
 
   async calculateFibonacci(num: number): Promise<{ result: number }> {
     const useRemoteFibService = await this.client.getBooleanValue('use-remote-fib-service', false);
@@ -18,7 +18,7 @@ export class FibonacciService {
       return lastValueFrom(
         this.httpService
           .get<{ result: number }>(`${this.FIB_SERVICE_URL}/calculate`, {
-            params: { num },
+            params: {num},
             auth: {
               username: process.env.FIB_SERVICE_USER || '',
               password: process.env.FIB_SERVICE_PASS || '',

packages/fibonacci-service/src/app/app.module.ts

@@ -1,40 +1,18 @@
-import {MiddlewareConsumer, Module, NestModule} from '@nestjs/common';
-import {AppController} from './app.controller';
-import {LoggerModule} from 'nestjs-pino';
-import { FlagMetadata, OpenFeature } from '@openfeature/server-sdk';
-import {AsyncLocalStorageTransactionContext, LoggingHook, OpenFeatureLogger} from '@openfeature/extra';
-import {MetricsHook, TracingHook as SpanEventBasedTracingHook} from '@openfeature/open-telemetry-hooks';
-import {TransactionContextMiddleware} from './transaction-context.middleware';
-import {ProviderService} from '@openfeature/provider';
-import {ProvidersController} from './providers.controller';
-
-/**
- * Set a global logger for OpenFeature. This is logger will available in hooks.
- */
-OpenFeature.setLogger(new OpenFeatureLogger('OpenFeature'));
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { LoggerModule } from 'nestjs-pino';
+import { LoggingHook, OpenFeatureLogger } from '@openfeature/extra';
+import { MetricsHook, TracingHook as SpanEventBasedTracingHook } from '@openfeature/open-telemetry-hooks';
+import { ProviderService } from '@openfeature/provider';
+import { ProvidersController } from './providers.controller';
+import { OpenFeatureModule, FlagMetadata } from '@openfeature/nestjs-sdk';
 
 function attributeMapper(flagMetadata: FlagMetadata) {
   return {
     ...('scope' in flagMetadata && { scope: flagMetadata.scope }),
   };
 }
 
-/**
- * Adding hooks to at the global level will ensure they always run
- * as part of a flag evaluation lifecycle.
- */
-OpenFeature.addHooks(
-  new LoggingHook(),
-  new SpanEventBasedTracingHook({attributeMapper}),
-  new MetricsHook({ attributeMapper }));
-
-/**
- * The transaction context propagator is an experimental feature
- * that allows evaluation context to be set anywhere in a request
- * and have it automatically available during a flag evaluation.
- */
-OpenFeature.setTransactionContextPropagator(new AsyncLocalStorageTransactionContext());
-
 @Module({
   imports: [
     LoggerModule.forRoot({
@@ -57,12 +35,18 @@ OpenFeature.setTransactionContextPropagator(new AsyncLocalStorageTransactionCont
             : undefined,
       },
     }),
+    OpenFeatureModule.forRoot({
+      // Set a global logger for OpenFeature. This is logger will available in hooks.
+      logger: new OpenFeatureLogger('OpenFeature'),
+      //Adding hooks to at the global level will ensure they always run as part of a flag evaluation lifecycle.
+      hooks: [
+        new LoggingHook(),
+        new SpanEventBasedTracingHook({ attributeMapper }),
+        new MetricsHook({ attributeMapper }),
+      ],
+    }),
   ],
   controllers: [AppController, ProvidersController],
   providers: [ProviderService],
 })
-export class AppModule implements NestModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(TransactionContextMiddleware).forRoutes(AppController);
-  }
-}
+export class AppModule {}

packages/fibonacci/src/lib/fibonacci.ts

@@ -1,4 +1,4 @@
-import { OpenFeature } from '@openfeature/server-sdk';
+import { OpenFeature } from '@openfeature/nestjs-sdk';
 
 const oFeatClient = OpenFeature.getClient('fibonacci');
 

packages/openfeature-extra/src/index.ts

@@ -1,3 +1,2 @@
 export * from './lib/hooks';
-export * from './lib/transaction-context';
 export * from './lib/logger';

packages/openfeature-extra/src/lib/hooks/class-validator-hook.ts

@@ -1,4 +1,4 @@
-import { EvaluationDetails, Hook, HookContext, JsonObject } from '@openfeature/server-sdk';
+import { EvaluationDetails, Hook, HookContext, JsonObject } from '@openfeature/nestjs-sdk';
 import { validateSync } from 'class-validator';
 
 /* eslint-disable  @typescript-eslint/no-explicit-any */

packages/openfeature-extra/src/lib/hooks/logging-hook.ts

@@ -1,4 +1,4 @@
-import { EvaluationDetails, FlagValue, Hook, HookContext, HookHints } from '@openfeature/server-sdk';
+import { EvaluationDetails, FlagValue, Hook, HookContext, HookHints } from '@openfeature/nestjs-sdk';
 
 /**
  * A hook that simply logs at every life-cycle stage.

packages/openfeature-extra/src/lib/logger.ts

@@ -1,4 +1,4 @@
-import { Logger as OFLogger } from '@openfeature/server-sdk';
+import { Logger as OFLogger } from '@openfeature/nestjs-sdk';
 import { Logger } from '@nestjs/common';
 
 /**

packages/openfeature-propagator/src/lib/openfeature-propagator.ts

@@ -7,7 +7,7 @@ import {
   BaggageEntry,
 } from '@opentelemetry/api';
 import { isTracingSuppressed } from '@opentelemetry/core';
-import { OpenFeature, EvaluationContext } from '@openfeature/server-sdk';
+import { OpenFeature, EvaluationContext } from '@openfeature/nestjs-sdk';
 
 const KEY_PAIR_SEPARATOR = '=';
 const PROPERTIES_SEPARATOR = ';';