Feature/prefix

.lintstagedrc.json

@@ -0,0 +1,4 @@
+{
+  "*": "prettier --ignore-unknown --write",
+  "src/**/*.ts": "eslint --fix"
+}

.prettierignore

@@ -0,0 +1,4 @@
+dist
+node_modules
+coverage
+build

package.json

@@ -7,9 +7,7 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "start": "npx tsc && NODE_ENV=production node dist/server.js",
     "dev": "NODE_ENV=development ts-node-dev --respawn ./src/server.ts",
-    "prettify": "prettier --write .",
-    "lint:fix": "eslint src/**/*.ts",
-    "precommit": "npm run prettify && npm run lint:fix"
+    "precommit": "lint-staged --concurrent false"
   },
   "type": "commonjs",
   "repository": {
@@ -47,6 +45,7 @@
     "eslint-config-airbnb": "^19.0.0",
     "eslint-config-prettier": "^8.3.0",
     "husky": "^4.3.8",
+    "lint-staged": "^15.2.2",
     "nodemon": "^3.0.2",
     "prettier": "^2.4.1",
     "ts-node": "^10.9.2",

src/constants/index.ts

@@ -23,9 +23,11 @@ export const HTTP_CODES = {
 };
 export const HTTP_TEXTS = {
   UNAUTHORIZED: "You're unauthorized to access this resource.",
+  S3_ERROR: "Something went wrong while handing the file",
   INTERNAL_ERROR: "Internal server error, please try again later.",
   SOMETHING_WENT_WRONG:
     "Something went wrong while processing your request, please try again.",
+  CS_ERROR: "Contentstack API error",
   NO_CS_USER: "No user found with the credentials",
   SUCCESS_LOGIN: "Login Successful.",
   TOKEN_ERROR: "Error occurred during token generation.",
@@ -35,6 +37,7 @@ export const HTTP_TEXTS = {
   NO_PROJECT: "resource not found with the given ID(s).",
   MIGRATION_CREATED: "Project's migration created successfully.",
   MIGRATION_UPDATED: "Project's migration updated successfully.",
+  AFFIX_UPDATED: "Project's Affix updated successfully",
   CMS_UPDATED: "Project's migration cms updated successfully",
   FILE_FORMAT_UPDATED: "Project's migration file format updated successfully",
   DESTINATION_STACK_UPDATED:
@@ -68,6 +71,7 @@ export const VALIDATION_ERRORS = {
   STRING_REQUIRED: "Provided $ should be a string.",
   INVALID_REGION: "Provided region doesn't exists.",
   FIELD_REQUIRED: "Field '$' is required.",
+  INVALID_AFFIX: "Invalid affix format",
 };
 export const POPULATE_CONTENT_MAPPER = "content_mapper";
 export const POPULATE_FIELD_MAPPING = "fieldMapping";
@@ -76,3 +80,4 @@ export const CONTENT_TYPE_POPULATE_FIELDS =
 export const PROJECT_UNSELECTED_FIELDS =
   "-content_mapper -legacy_cms -destination_stack_id -execution_log";
 export const EXCLUDE_CONTENT_MAPPER = "-content_mapper -execution_log";
+export const AFFIX_REGEX = /^[a-zA-Z][a-zA-Z0-9]{1,4}$/;

src/controllers/projects.controller.ts

@@ -31,6 +31,11 @@ const updateLegacyCMS = async (req: Request, res: Response) => {
   res.status(resp.status).json(resp.data);
 };
 
+const updateAffix = async (req: Request, res: Response) => {
+  const resp = await projectService.updateAffix(req);
+  res.status(resp.status).json(resp.data);
+};
+
 const updateFileFormat = async (req: Request, res: Response) => {
   const resp = await projectService.updateFileFormat(req);
   res.status(resp.status).json(resp.data);
@@ -53,6 +58,7 @@ export const projectController = {
   createProject,
   updateProject,
   updateLegacyCMS,
+  updateAffix,
   updateFileFormat,
   updateDestinationStack,
   deleteProject,

src/controllers/user.controller.ts

@@ -1,10 +1,9 @@
 import { Request, Response } from "express";
 import { userService } from "../services/user.service";
-import { HTTP_CODES } from "../constants";
 
 const getUserProfile = async (req: Request, res: Response) => {
-  const user = await userService.getUserProfile(req);
-  res.status(HTTP_CODES.OK).json(user);
+  const resp = await userService.getUserProfile(req);
+  res.status(resp?.status).json(resp?.data);
 };
 
 export const userController = {

src/database.ts

@@ -4,7 +4,6 @@ import { config } from "./config";
 import logger from "./utils/logger";
 import ProjectModel from "./models/project";
 import AuthenticationModel from "./models/authentication";
-import AuditLogModel from "./models/auditLog";
 import ContentTypesMapperModel from "./models/contentTypesMapper";
 import FieldMapperModel from "./models/FieldMapper";
 
@@ -19,7 +18,6 @@ const connectToDatabase = async () => {
     // Create the collection's if it doesn't exist
     await ProjectModel.init();
     await AuthenticationModel.init();
-    await AuditLogModel.init();
     await ContentTypesMapperModel.init();
     await FieldMapperModel.init();
   } catch (error) {

src/models/project.ts

@@ -3,6 +3,7 @@ import { CS_REGIONS } from "../constants";
 
 interface LegacyCMS {
   cms: string;
+  affix: string;
   file_format: string;
   import_data: string;
 }
@@ -44,6 +45,7 @@ const projectSchema = new Schema<ProjectDocument>(
     destination_stack_id: { type: String },
     legacy_cms: {
       cms: { type: String },
+      affix: { type: String },
       file_format: { type: String },
       import_data: { type: String },
     },

src/models/types.ts

@@ -3,15 +3,6 @@ export interface User {
   password: string;
 }
 
-export interface UserProfile {
-  user: {
-    email: string;
-    first_name: string;
-    last_name: string;
-    orgs: [{ org_id: string; org_name: string }];
-  };
-}
-
 export interface AppTokenPayload {
   region: string;
   user_id: string;

src/routes/projects.routes.ts

@@ -25,6 +25,13 @@ router.put(
   asyncRouter(projectController.updateLegacyCMS)
 );
 
+// Update project's Affix
+router.put(
+  "/:projectId/affix",
+  validator("affix"),
+  asyncRouter(projectController.updateAffix)
+);
+
 // Update project's file format
 router.put(
   "/:projectId/file-format",

src/services/auth.service.ts

@@ -1,84 +1,102 @@
 import { Request } from "express";
 import { config } from "../config";
-import { safePromise } from "../utils/index";
+import { safePromise, getLogMessage } from "../utils";
 import https from "../utils/https.utils";
 import { LoginServiceType, AppTokenPayload } from "../models/types";
 import { HTTP_CODES, HTTP_TEXTS } from "../constants";
 import { generateToken } from "../utils/jwt.utils";
 import {
   BadRequestError,
   InternalServerError,
+  ExceptionFunction,
 } from "../utils/custom-errors.utils";
 import AuthenticationModel from "../models/authentication";
+import logger from "../utils/logger";
 
 const login = async (req: Request): Promise<LoginServiceType> => {
-  const userData = req?.body;
-
-  const [err, res] = await safePromise(
-    https({
-      method: "POST",
-      url: `${config.CS_API[
-        userData?.region as keyof typeof config.CS_API
-      ]!}/user-session`,
-      headers: {
-        "Content-Type": "application/json",
-      },
-      data: {
-        user: {
-          email: userData?.email,
-          password: userData?.password,
-          ...(userData?.tfa_token && { tfa_token: userData?.tfa_token }),
+  const srcFun = "Login";
+
+  try {
+    const userData = req?.body;
+
+    const [err, res] = await safePromise(
+      https({
+        method: "POST",
+        url: `${config.CS_API[
+          userData?.region as keyof typeof config.CS_API
+        ]!}/user-session`,
+        headers: {
+          "Content-Type": "application/json",
         },
-      },
-    })
-  );
+        data: {
+          user: {
+            email: userData?.email,
+            password: userData?.password,
+            ...(userData?.tfa_token && { tfa_token: userData?.tfa_token }),
+          },
+        },
+      })
+    );
 
-  if (err)
-    return {
-      data: err?.response?.data,
-      status: err?.response?.status,
+    if (err) {
+      logger.error(
+        getLogMessage(srcFun, HTTP_TEXTS.CS_ERROR, {}, err?.response?.data)
+      );
+
+      return {
+        data: err?.response?.data,
+        status: err?.response?.status,
+      };
+    }
+
+    if (res?.status === HTTP_CODES.SUPPORT_DOC)
+      return {
+        data: res?.data,
+        status: res?.status,
+      };
+
+    if (!res?.data?.user) throw new BadRequestError(HTTP_TEXTS.NO_CS_USER);
+
+    const appTokenPayload: AppTokenPayload = {
+      region: userData?.region,
+      user_id: res?.data?.user.uid,
     };
 
-  if (res?.status === HTTP_CODES.SUPPORT_DOC)
+    // Saving auth info in the DB
+    await AuthenticationModel.findOneAndUpdate(
+      appTokenPayload,
+      {
+        authtoken: res?.data.user?.authtoken,
+      },
+      {
+        upsert: true,
+      }
+    );
+
+    // JWT token generation
+    const app_token = generateToken(appTokenPayload);
+
     return {
-      data: res?.data,
-      status: res?.status,
+      data: {
+        message: HTTP_TEXTS.SUCCESS_LOGIN,
+        app_token,
+      },
+      status: HTTP_CODES.OK,
     };
-
-  if (!res?.data?.user) throw new BadRequestError(HTTP_TEXTS.NO_CS_USER);
-
-  const appTokenPayload: AppTokenPayload = {
-    region: userData?.region,
-    user_id: res?.data?.user.uid,
-  };
-
-  // Saving auth info in the DB
-  await AuthenticationModel.findOneAndUpdate(
-    appTokenPayload,
-    {
-      authtoken: res?.data.user?.authtoken,
-    },
-    {
-      upsert: true,
-    }
-  );
-
-  // JWT token generation
-  const app_token = generateToken(appTokenPayload);
-
-  return {
-    data: {
-      message: HTTP_TEXTS.SUCCESS_LOGIN,
-      app_token,
-    },
-    status: HTTP_CODES.OK,
-  };
+  } catch (error: any) {
+    logger.error(getLogMessage(srcFun, "Error while logging in", {}, error));
+    throw new ExceptionFunction(
+      error?.message || HTTP_TEXTS.INTERNAL_ERROR,
+      error?.statusCode || error?.status || HTTP_CODES.SERVER_ERROR
+    );
+  }
 };
 
 const requestSms = async (req: Request): Promise<LoginServiceType> => {
-  const userData = req?.body;
+  const srcFun = "requestSms";
 
   try {
+    const userData = req?.body;
     const [err, res] = await safePromise(
       https({
         method: "POST",
@@ -94,17 +112,24 @@ const requestSms = async (req: Request): Promise<LoginServiceType> => {
       })
     );
 
-    if (err)
+    if (err) {
+      logger.error(
+        getLogMessage(srcFun, HTTP_TEXTS.CS_ERROR, {}, err?.response?.data)
+      );
+
       return {
-        data: err.response.data,
-        status: err.response.status,
+        data: err?.response?.data,
+        status: err?.response?.status,
       };
+    }
 
     return {
       data: res.data,
       status: res.status,
     };
-  } catch (error) {
+  } catch (error: any) {
+    logger.error(getLogMessage(srcFun, "Error while in requestSms", {}, error));
+
     throw new InternalServerError(HTTP_TEXTS.INTERNAL_ERROR);
   }
 };