Add: Feature flag service backend integration

config/custom-environment-variables.js

@@ -61,6 +61,10 @@ module.exports = {
     discordBot: {
       baseUrl: "DISCORD_BASE_URL",
     },
+    featureFlag: {
+      baseUrl: "FEATURE_FLAG_SERVICE_BASE_URL",
+      apiKey: "FEATURE_FLAG_SERVICE_API_KEY",
+    },
   },
 
   emailServiceConfig: {

config/default.js

@@ -70,10 +70,14 @@
     discordBot: {
       baseUrl: "<DISCORD_BOT_BASE_URL>",
     },
+    featureFlag: {
+      baseUrl: "<FEATURE_FLAG_SERVICE_BASE_URL>",
+      apiKey: "<FEATURE_FLAG_SERVICE_API_KEY>",
+    },
   },
 
   cors: {
     allowedOrigins: /(https:\/\/([a-zA-Z0-9-_]+\.)?realdevsquad\.com$)/, // Allow realdevsquad.com, *.realdevsquad.com
   },
 
   userToken: {

controllers/featureFlags.ts

@@ -0,0 +1,73 @@
+import { CustomRequest, CustomResponse } from "../types/global";
+import featureFlagService from "../services/featureFlagService";
+import { FeatureFlag, UpdateFeatureFlagRequestBody } from "../types/featureFlags";
+
+export const getAllFeatureFlags = async (req: CustomRequest, res: CustomResponse) => {
+  try {
+    const serviceResponse = await featureFlagService.getAllFeatureFlags();
+
+    if (serviceResponse.error) {
+      return res.status(serviceResponse.status).json({
+        error: serviceResponse.error.message
+      });
+    }
+
+    return res.status(200).json({
+      message: "Feature flags retrieved successfully",
+      data: serviceResponse
+    });
+
+  } catch (err) {
+    logger.error(`Error in fetching feature flags: ${err}`);
+    return res.boom.badImplementation('Internal server error');
+  }
+};
+
+
+export const getFeatureFlagById = async (req: CustomRequest, res: CustomResponse) => {
+  try {
+    const { flagId } = req.params;
+    const serviceResponse = await featureFlagService.getFeatureFlagById(flagId);
+
+    if (serviceResponse.data) {
+      return res.status(serviceResponse.status).json({
+        message: "Feature flag retrieved successfully",
+        data: serviceResponse.data,
+      });
+    } else if (serviceResponse.error) {
+      return res.status(serviceResponse.status).json({
+        error: serviceResponse.error.message || "Internal server error",
+      });
+    } else {
+      return res.status(500).json({ error: "Unknown error occurred" });
+    }
+  } catch (err) {
+    logger.error(`Unexpected error in fetching feature flag: ${err}`);
+    return res.boom.badImplementation("Internal server error");
+  }
+};
+
+export const createFeatureFlag = async (req: CustomRequest, res: CustomResponse) => {
+  try {
+    const flagData: Partial<FeatureFlag> = req.body as Partial<FeatureFlag>;
+
+    const serviceResponse = await featureFlagService.createFeatureFlag(flagData);
+
+    if (serviceResponse.data) {
+      return res.status(serviceResponse.status).json({
+        message: "Feature flag created successfully",
+        data: serviceResponse.data,
+      });
+    } else if (serviceResponse.error) {
+
+      return res.status(serviceResponse.status).json({
+        error: serviceResponse.error.message || "Internal server error",
+      });
+    } else {
+      return res.status(500).json({ error: "Unknown error occurred" });
+    }
+  } catch (err) {
+    logger.error(`Unexpected error in creating feature flag: ${err}`);
+    return res.boom.badImplementation("Internal server error.");
+  }
+};

middlewares/validators/featureFlag.ts

@@ -0,0 +1,31 @@
+import Joi from 'joi';
+import { Request, Response, NextFunction } from 'express';
+import { CustomResponse } from '../../types/global';
+
+const createFeatureFlagSchema = Joi.object({
+	Name: Joi.string()
+		.required()
+		.messages({
+			'any.required': 'Name is required'
+		}),
+	Description: Joi.string()
+		.required()
+		.messages({
+			'any.required': 'Description is required'
+		}),
+	UserId: Joi.string()
+		.required()
+		.messages({
+			'any.required': 'UserId is required'
+		})
+});
+
+export const validateCreateFeatureFlag = async (req: Request, res: CustomResponse, next: NextFunction) => {
+	try {
+		await createFeatureFlagSchema.validateAsync(req.body);
+		next();
+	} catch (error) {
+		logger.error(`Error validating create feature flag payload: ${error.message}`);
+		res.boom.badRequest(error.message);
+	}
+};

routes/featureFlag.ts

@@ -0,0 +1,13 @@
+import express from "express";
+const router = express.Router();
+import authenticate from "../middlewares/authenticate";
+const authorizeRoles = require("../middlewares/authorizeRoles");
+import { createFeatureFlag, getAllFeatureFlags, getFeatureFlagById } from "../controllers/featureFlags";
+const { SUPERUSER } = require("../constants/roles");
+import { validateCreateFeatureFlag } from '../middlewares/validators/featureFlag';
+
+router.get("/getAllFeatureFlags", authenticate, getAllFeatureFlags);
+router.get("/getFeatureFlag/:flagId", authenticate, getFeatureFlagById);
+router.post('/createFeatureFlag', authenticate, authorizeRoles([SUPERUSER]), validateCreateFeatureFlag, createFeatureFlag);
+
+module.exports = router;

routes/index.ts

@@ -42,4 +42,6 @@ app.use("/goals", require("./goals"));
 app.use("/invites", require("./invites"));
 app.use("/requests", require("./requests"));
 app.use("/subscription", devFlagMiddleware, require("./subscription"));
+app.use("/feature-flag", require("./featureFlag"));
+
 module.exports = app;

services/featureFlagService.ts

@@ -0,0 +1,103 @@
+import config from "config";
+import { FeatureFlag, FeatureFlagResponse, FeatureFlagService } from "../types/featureFlags";
+
+const FEATURE_FLAG_BASE_URL = config.get<string>("services.featureFlag.baseUrl");
+const FEATURE_FLAG_API_KEY = config.get<string>("services.featureFlag.apiKey");
+
+const defaultHeaders: HeadersInit = {
+    "Content-Type": "application/json",
+    "x-api-key": FEATURE_FLAG_API_KEY,
+};
+
+const getAllFeatureFlags = async (): Promise<FeatureFlagResponse> => {
+  try {
+    const response = await fetch(`${FEATURE_FLAG_BASE_URL}/feature-flags`, {
+      method: "GET",
+        headers: defaultHeaders,
+    });
+
+    if (!response.ok) {
+      logger.error(`Failed to fetch feature flags. Status: ${response.status}`);
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (err) {
+    logger.error("Error in fetching feature flags", err);
+    return { status: 500, error: { message: "Internal error while connecting to the feature flag service" } };
+  }
+};
+
+const createFeatureFlag = async (flagData: any): Promise<{ status: number; data?: any; error?: any }> => {
+    try {
+        const response = await fetch(`${FEATURE_FLAG_BASE_URL}/feature-flags`, {
+            method: "POST",
+            headers: defaultHeaders,
+            body: JSON.stringify(flagData),
+        });
+        const status = response.status;
+
+        if (response.ok) {
+            const data = await response.json().catch(() => ({
+                message: "Feature flag created successfully",
+            }));
+            return { status, data };
+        } else {
+            const error = await response.json().catch(() => ({
+                message: "An error occurred while creating the feature flag",
+            }));
+            return { status, error };
+        }
+    } catch (err) {
+        logger.error("Error in createFeatureFlag service:", err);
+        return { status: 500, error: { message: "Internal error while connecting to the feature flag service" } };
+    }
+};
+
+const getFeatureFlagById = async (flagId: string): Promise<{ status: number; data?: any; error?: any }> => {
+    try {
+        const response = await fetch(`${FEATURE_FLAG_BASE_URL}/feature-flags/${flagId}`, {
+            method: "GET",
+            headers: defaultHeaders,
+        });
+        const status = response.status;
+        const responseText = await response.text();
+
+        if (response.ok) {
+            try {
+                const parsedData = JSON.parse(responseText);
+                return { 
+                    status,
+                    data: parsedData
+                };
+            } catch (parseError) {
+                logger.error("Error parsing success response:", parseError);
+                return {
+                    status: 500,
+                    error: { message: "Error parsing service response" }
+                };
+            }
+        }
+        return { 
+            status,
+            error: { message: responseText }
+        };
+    } catch (err) {
+        logger.error("Error in getFeatureFlagById service:", err);
+        return { 
+            status: 500, 
+            error: { 
+                message: err instanceof Error ? err.message : "Internal error while connecting to the feature flag service" 
+            } 
+        };
+    }
+};
+
+const featureFlagService: FeatureFlagService = {
+  getAllFeatureFlags,
+  createFeatureFlag,
+  getFeatureFlagById,
+};
+
+export default featureFlagService; 

test/config/test.js

@@ -72,6 +72,10 @@ module.exports = {
       secretKey: "<goalSecretKey>",
       cookieName: `goals-session-test`,
     },
+    featureFlag: {
+      baseUrl: "FEATURE_FLAG_SERVICE_BASE_URL",
+      apiKey: "FEATURE_FLAG_SERVICE_API_KEY",
+    },
   },
 
   cors: {

test/fixtures/featureFlag/featureFlag.ts

@@ -0,0 +1,60 @@
+interface FeatureFlag {
+  id: string;
+  name: string;
+  description: string;
+  status: string;
+  createdAt: number;
+  createdBy: string;
+  updatedAt: number;
+  updatedBy: string;
+}
+
+const featureFlagData = [
+  {
+    id: "60b00c3a-3928-4f0c-8581-dfce71aa8605",
+    name: "feature-flag",
+    description: "It is a demo project",
+    status: "ENABLED",
+    createdAt: 1718139019,
+    createdBy: "sduhasdjasdas",
+    updatedAt: 1718139019,
+    updatedBy: "sduhasdjasdas"
+  },
+  {
+    id: "flag-1",
+    name: "feature-flag-1",
+    description: "First demo flag",
+    status: "ENABLED",
+    createdAt: 1718139019,
+    createdBy: "user1",
+    updatedAt: 1718139019,
+    updatedBy: "user1"
+  },
+  {
+    id: "flag-2",
+    name: "feature-flag-2",
+    description: "Second demo flag",
+    status: "DISABLED",
+    createdAt: 1718139019,
+    createdBy: "user2",
+    updatedAt: 1718139019,
+    updatedBy: "user2"
+  }
+];
+
+const newFeatureFlag = {
+  Name: "Demo-feature",
+  Description: "Description for demo feature",
+  UserId: "superUserId"
+};
+
+const invalidFeatureFlag = {
+  Description: "Missing required name",
+  UserId: "superUserId"
+};
+
+module.exports = {
+  featureFlagData,
+  newFeatureFlag,
+  invalidFeatureFlag
+}; 

types/featureFlags.ts

@@ -0,0 +1,29 @@
+export interface FeatureFlag {
+  id?: string;
+  name: string;
+  description?: string;
+  status: string;
+  createdAt?: number;
+  updatedAt?: number;
+  createdBy: string
+  updatedBy: string
+}
+
+export interface FeatureFlagResponse {
+  status: number;
+  data?: FeatureFlag | FeatureFlag[];
+  error?: {
+    message: string;
+  };
+}
+
+export interface FeatureFlagService {
+  getAllFeatureFlags(): Promise<FeatureFlagResponse>;
+  createFeatureFlag(flagData: Partial<FeatureFlag>): Promise<FeatureFlagResponse>;
+	getFeatureFlagById: (flagId: string) => Promise<FeatureFlagResponse>;
+} 
+
+export interface UpdateFeatureFlagRequestBody {
+	Status: string;
+	UserId: string;
+}