add: get feature flag by ID api

MehulKChaudhari · MehulKChaudhari · commit 435675d8191e · 2024-11-25T22:40:56.000+05:30
diff --git a/controllers/featureFlags.ts b/controllers/featureFlags.ts
@@ -1,29 +1,48 @@
 import { CustomRequest, CustomResponse } from "../types/global";
 import featureFlagService from "../services/featureFlagService";
-import { FeatureFlag } from "../types/featureFlags";
+import { FeatureFlag, UpdateFeatureFlagRequestBody } from "../types/featureFlags";
 
 export const getAllFeatureFlags = async (req: CustomRequest, res: CustomResponse) => {
   try {
     const serviceResponse = await featureFlagService.getAllFeatureFlags();
     
-    if (serviceResponse.data) {
-      return res.status(serviceResponse.status || 200).json({
-        message: "Feature flags retrieved successfully",
-        data: serviceResponse.data,
+    if (!serviceResponse) {
+      return res.status(500).json({ 
+        error: "Failed to fetch feature flags" 
       });
-    } else if (serviceResponse.error) {
-      return res.status(serviceResponse.status || 500).json({
-        error: serviceResponse.error.message || "Internal server error",
-      });
-    } else {
-      return res.status(500).json({ error: "Unknown error occurred" });
     }
+
+    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>;
@@ -53,9 +72,24 @@ export const createFeatureFlag = async (req: CustomRequest, res: CustomResponse)
 export const updateFeatureFlag = async (req: CustomRequest, res: CustomResponse) => {
   try {
     const { flagId } = req.params;
-    const updateData: Partial<FeatureFlag> = req.body;
-    const response = await featureFlagService.updateFeatureFlag(flagId, updateData);
-    res.json(response);
+    console.log("Mehulllll", flagId)
+    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');
diff --git a/middlewares/validators/featureFlag.ts b/middlewares/validators/featureFlag.ts
@@ -0,0 +1,28 @@
+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);
+  }
+}; 
diff --git a/routes/featureFlag.ts b/routes/featureFlag.ts
@@ -2,11 +2,13 @@ import express from "express";
 const router = express.Router();
 import authenticate from "../middlewares/authenticate";
 const authorizeRoles = require("../middlewares/authorizeRoles");
-import { getAllFeatureFlags, createFeatureFlag, updateFeatureFlag } from "../controllers/featureFlags";
+import { createFeatureFlag, getAllFeatureFlags, getFeatureFlagById, updateFeatureFlag} from "../controllers/featureFlags";
 const { SUPERUSER } = require("../constants/roles");
+import { validateUpdateFeatureFlag } from '../middlewares/validators/featureFlag';
 
 router.get("/getAllFeatureFlags", authenticate, getAllFeatureFlags);
-router.post('/createFeatureFlag', authenticate, authorizeRoles(SUPERUSER), createFeatureFlag);
-router.patch('/updateFeatureFlag/:flagId', authenticate, authorizeRoles(SUPERUSER), updateFeatureFlag);
+router.get("/getFeatureFlag/:flagId", authenticate, getFeatureFlagById);
+router.post('/createFeatureFlag', authenticate, authorizeRoles([SUPERUSER]), createFeatureFlag);
+router.patch('/updateFeatureFlag/:flagId', authenticate, authorizeRoles([SUPERUSER]), validateUpdateFeatureFlag, updateFeatureFlag);
 
 module.exports = router;
diff --git a/services/featureFlagService.ts b/services/featureFlagService.ts
@@ -1,5 +1,5 @@
 import config from "config";
-import { FeatureFlag, FeatureFlagResponse, FeatureFlagService } from "../types/featureFlags";
+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");
@@ -17,11 +17,17 @@ const getAllFeatureFlags = async (): Promise<FeatureFlagResponse> => {
       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" } };
+    return { status: 500, error: { message: "Internal error while connecting to the feature flag service" } };
   }
 };
 
@@ -51,29 +57,67 @@ const createFeatureFlag = async (flagData: any): Promise<{ status: number; data?
     }
 };
 
-
 const updateFeatureFlag = async (
-  flagId: string, 
-  updateData: Partial<FeatureFlag>
+    flagId: string,
+    updateData: UpdateFeatureFlagRequestBody
 ): Promise<FeatureFlagResponse> => {
+    try {
+        const response = await fetch(`http://127.0.0.1:3000/feature-flags/${flagId}`, {
+            method: "PATCH",
+            headers: generateHeaders(),
+            body: JSON.stringify(updateData),
+        });
+        console.log("Mehulllll", response)
+        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: "PUT",
+      method: "GET",
       headers: generateHeaders(),
-      body: JSON.stringify(updateData),
     });
+
+    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 data;
+    return { status: response.status, data };
   } catch (err) {
-    logger.error("Error in updating feature flag", err);
-    throw 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; 
diff --git a/types/featureFlags.ts b/types/featureFlags.ts
@@ -20,5 +20,11 @@ export interface FeatureFlagResponse {
 export interface FeatureFlagService {
   getAllFeatureFlags(): Promise<FeatureFlagResponse>;
   createFeatureFlag(flagData: Partial<FeatureFlag>): Promise<FeatureFlagResponse>;
-  updateFeatureFlag(flagId: string, updateData: Partial<FeatureFlag>): Promise<FeatureFlagResponse>;
-} 
+  updateFeatureFlag(flagId: string, updateData: UpdateFeatureFlagRequestBody): Promise<FeatureFlagResponse>;
+	getFeatureFlagById: (flagId: string) => Promise<FeatureFlagResponse>;
+} 
+
+export interface UpdateFeatureFlagRequestBody {
+	Status: string;
+	UserId: string;
+}
