Add: Feature flag service backend integration

config/default.js

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

controllers/featureFlags.ts

@@ -0,0 +1,97 @@
+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) {
+      return res.status(500).json({ 
+        error: "Failed to fetch feature flags" 
+      });
+    }
+
+    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) {
+      return res.status(404).json({ error: "Feature flag not found" });
+    }
+
+    return res.status(200).json({
+      message: "Feature flag retrieved successfully",
+      data: serviceResponse
+    });
+  } catch (err) {
+    logger.error(`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.");
+  }
+};
+
+
+export const updateFeatureFlag = async (req: CustomRequest, res: CustomResponse) => {
+  try {
+    const { flagId } = req.params;
+    const updateData: UpdateFeatureFlagRequestBody = {
+      Status: req.body.Status,
+      UserId: req.body.UserId,
+    };
+
+    const serviceResponse = await featureFlagService.updateFeatureFlag(flagId, updateData);
+
+    if (serviceResponse.status >= 400) {
+      return res.status(serviceResponse.status).json({
+        error: serviceResponse.error?.message || "An error occurred while updating the feature flag",
+      });
+    }
+
+    return res.status(serviceResponse.status).json({
+      message: "Feature flag updated successfully",
+      data: serviceResponse.data,
+    });
+  } catch (err) {
+    logger.error(`Error in updating feature flag: ${err}`);
+    return res.boom.badImplementation('Internal server error');
+  }
+};
+

middlewares/validators/featureFlag.ts

@@ -0,0 +1,56 @@
+import Joi from 'joi';
+import { Request, Response, NextFunction } from 'express';
+import { CustomResponse } from '../../types/global';
+
+const updateFeatureFlagSchema = Joi.object({
+  Status: Joi.string()
+    .valid('ENABLED', 'DISABLED')
+    .required()
+    .messages({
+      'string.valid': 'Allowed values of Status are ENABLED, DISABLED',
+      'any.required': 'Status is required'
+    }),
+  UserId: Joi.string()
+    .required()
+    .messages({
+      'any.required': 'UserId is required'
+    })
+});
+
+export const validateUpdateFeatureFlag = async (req: Request, res: CustomResponse, next: NextFunction) => {
+  try {
+    await updateFeatureFlagSchema.validateAsync(req.body);
+    next();
+  } catch (error) {
+    logger.error(`Error validating update feature flag payload: ${error.message}`);
+    res.boom.badRequest(error.message);
+  }
+};
+
+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,14 @@
+import express from "express";
+const router = express.Router();
+import authenticate from "../middlewares/authenticate";
+const authorizeRoles = require("../middlewares/authorizeRoles");
+import { createFeatureFlag, getAllFeatureFlags, getFeatureFlagById, updateFeatureFlag } from "../controllers/featureFlags";
+const { SUPERUSER } = require("../constants/roles");
+import { validateUpdateFeatureFlag, validateCreateFeatureFlag } from '../middlewares/validators/featureFlag';
+
+router.get("/getAllFeatureFlags", authenticate, getAllFeatureFlags);
+router.get("/getFeatureFlag/:flagId", authenticate, getFeatureFlagById);
+router.post('/createFeatureFlag', authenticate, authorizeRoles([SUPERUSER]), validateCreateFeatureFlag, createFeatureFlag);
+router.patch('/updateFeatureFlag/:flagId', authenticate, authorizeRoles([SUPERUSER]), validateUpdateFeatureFlag, updateFeatureFlag);
+
+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,123 @@
+import config from "config";
+import { FeatureFlag, FeatureFlagResponse, FeatureFlagService, UpdateFeatureFlagRequestBody } 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 generateHeaders = (): HeadersInit => {
+  return {
+    "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: generateHeaders(),
+    });
+
+    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: generateHeaders(),
+            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 updateFeatureFlag = async (
+    flagId: string,
+    updateData: UpdateFeatureFlagRequestBody
+): Promise<FeatureFlagResponse> => {
+    try {
+        const response = await fetch(`${FEATURE_FLAG_BASE_URL}/feature-flags/${flagId}`, {
+            method: "PATCH",
+            headers: generateHeaders(),
+            body: JSON.stringify(updateData),
+        });
+
+        if (!response.ok) {
+            const error = await response.json();
+            return {
+                status: response.status,
+                error: error || { message: `HTTP error! status: ${response.status}` }
+            };
+        }
+
+        const data = await response.json();
+        return { status: response.status, data };
+    } catch (err) {
+        logger.error("Error in updating feature flag", err);
+        return {
+            status: 500,
+            error: { message: "Internal error while connecting to the feature flag service" }
+        };
+    }
+};
+
+const getFeatureFlagById = async (flagId: string): Promise<FeatureFlagResponse> => {
+  try {
+    const response = await fetch(`${FEATURE_FLAG_BASE_URL}/feature-flags/${flagId}`, {
+      method: "GET",
+      headers: generateHeaders(),
+    });
+
+    if (!response.ok) {
+      logger.error(`Failed to fetch feature flag. Status: ${response.status}`);
+      return {
+        status: response.status,
+        error: { message: `HTTP error! status: ${response.status}` }
+      };
+    }
+
+    const data = await response.json();
+    return { status: response.status, data };
+  } catch (err) {
+    logger.error("Error in fetching feature flag by ID", err);
+    return {
+      status: 500,
+      error: { message: "Internal error while connecting to the feature flag service" }
+    };
+  }
+};
+
+const featureFlagService: FeatureFlagService = {
+  getAllFeatureFlags,
+  createFeatureFlag,
+  updateFeatureFlag,
+  getFeatureFlagById,
+};
+
+export default featureFlagService; 

types/featureFlags.ts

@@ -0,0 +1,30 @@
+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>;
+  updateFeatureFlag(flagId: string, updateData: UpdateFeatureFlagRequestBody): Promise<FeatureFlagResponse>;
+	getFeatureFlagById: (flagId: string) => Promise<FeatureFlagResponse>;
+} 
+
+export interface UpdateFeatureFlagRequestBody {
+	Status: string;
+	UserId: string;
+}