feat: added content mapper models and endpoints

src/constants/index.ts

@@ -32,6 +32,11 @@ export const constants = {
     MIGRATION_DELETED: "Project's migration deleted successfully.",
     INVALID_ID: "Provided $ ID is invalid.",
     MIGRATION_EXISTS: "Project's migration already exists.",
+    PROJECT_NOT_FOUND: "Project does not exist",
+    CONTENT_TYPE_NOT_FOUND: "ContentType does not exist",
+    INVALID_CONTENT_TYPE: "Provide valid ContentType data",
+    RESET_CONTENT_MAPPING:
+      "ContentType has been successfully restored to its initial mapping",
   },
   HTTP_RESPONSE_HEADERS: {
     "Access-Control-Allow-Origin": "*",
@@ -47,3 +52,6 @@ export const constants = {
     INVALID_REGION: "Provided region doesn't exists.",
   },
 };
+export const PROJECT_POPULATE_FIELDS = "migration.modules.content_mapper";
+export const CONTENT_TYPE_POPULATE_FIELDS =
+  "otherCmsTitle otherCmsUid isUpdated updateAt contentstackTitle contnetStackUid";

src/controllers/projects.contentMapper.controller.ts

@@ -0,0 +1,42 @@
+import { Request, Response } from "express";
+import { contentMapperService } from "../services/contentMapper.service";
+const putTestData = async (req: Request, res: Response): Promise<void> => {
+  const resp = await contentMapperService.putTestData(req);
+  res.status(200).json(resp);
+};
+
+const getContentTypes = async (req: Request, res: Response): Promise<void> => {
+  const resp = await contentMapperService.getContentTypes(req);
+  res.status(200).json(resp);
+};
+const getFieldMapping = async (req: Request, res: Response): Promise<void> => {
+  const resp = await contentMapperService.getFieldMapping(req);
+  res.status(200).json(resp);
+};
+const getExistingContentTypes = async (
+  req: Request,
+  res: Response
+): Promise<void> => {
+  const resp = await contentMapperService.getExistingContentTypes(req);
+  res.status(201).json(resp);
+};
+const putContentTypeFields = async (
+  req: Request,
+  res: Response
+): Promise<void> => {
+  const resp = await contentMapperService.udateContentType(req);
+  res.status(200).json(resp);
+};
+const resetContentType = async (req: Request, res: Response): Promise<void> => {
+  const resp = await contentMapperService.resetToInitialMapping(req);
+  res.status(200).json(resp);
+};
+
+export const contentMapperController = {
+  getContentTypes,
+  getFieldMapping,
+  getExistingContentTypes,
+  putTestData,
+  putContentTypeFields,
+  resetContentType,
+};

src/database.ts

@@ -5,6 +5,8 @@ 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";
 
 const connectToDatabase = async () => {
   try {
@@ -18,6 +20,8 @@ const connectToDatabase = async () => {
     await ProjectModel.init();
     await AuthenticationModel.init();
     await AuditLogModel.init();
+    await ContentTypesMapperModel.init();
+    await FieldMapperModel.init();
   } catch (error) {
     logger.error("Error while connecting to MongoDB:", error);
     process.exit(1);

src/models/FieldMapper.ts

@@ -0,0 +1,32 @@
+import { Schema, model, Document } from "mongoose";
+
+interface FieldMapper extends Document {
+  uid: string;
+  otherCmsField: string;
+  otherCmsType: string;
+  contentstackField: string;
+  contentstackFieldUid: string;
+  ContentstackFieldType: string;
+  isDeleted: boolean;
+  backupFieldType: string;
+  refrenceTo: { uid: string; title: string };
+}
+
+const fieldMapperSchema = new Schema<FieldMapper>({
+  uid: { type: String, required: true },
+  otherCmsField: { type: String, required: true },
+  otherCmsType: { type: String, required: true },
+  contentstackField: { type: String },
+  contentstackFieldUid: { type: String },
+  ContentstackFieldType: { type: String, required: true },
+  isDeleted: { type: Boolean, default: false },
+  backupFieldType: { type: String },
+  refrenceTo: {
+    uid: { type: String },
+    title: { type: String },
+  },
+});
+
+const FieldMapperModel = model<FieldMapper>("FieldMapping", fieldMapperSchema);
+
+export default FieldMapperModel;

src/models/contentTypesMapper.ts

@@ -0,0 +1,28 @@
+import { Schema, model, Document } from "mongoose";
+
+interface ContentTypesMapper extends Document {
+  otherCmsTitle: string;
+  otherCmsUid: string;
+  isUpdated: boolean;
+  updateAt: Date;
+  contentstackTitle: string;
+  contnetStackUid: string;
+  fieldMapping: [];
+}
+
+const contentTypesMapperSchema = new Schema<ContentTypesMapper>({
+  otherCmsTitle: { type: String, required: true },
+  otherCmsUid: { type: String, required: true },
+  isUpdated: { type: Boolean, default: false },
+  updateAt: { type: Date },
+  contentstackTitle: { type: String },
+  contnetStackUid: { type: String },
+  fieldMapping: [{ type: Schema.Types.ObjectId, ref: "FieldMapping" }],
+});
+
+const ContentTypesMapperModel = model<ContentTypesMapper>(
+  "ContentTypes Mapper",
+  contentTypesMapperSchema
+);
+
+export default ContentTypesMapperModel;

src/models/project.ts

@@ -65,6 +65,9 @@ const projectSchema = new Schema<ProjectDocument>(
           stack_id: { type: String },
           org_id: { type: String },
         },
+        content_mapper: [
+          { type: Schema.Types.ObjectId, ref: "ContentTypes Mapper" },
+        ],
       },
     },
     execution_log: {

src/routes/contentMapper.routes.ts

@@ -0,0 +1,40 @@
+import express from "express";
+import { contentMapperController } from "../controllers/projects.contentMapper.controller";
+import { asyncRouter } from "../utils/async-router.utils";
+
+const router = express.Router({ mergeParams: true });
+
+//Developer End Point to create dummy data
+router.post(
+  "/createDummyData/:projectId",
+  asyncRouter(contentMapperController.putTestData)
+);
+
+//Get ContentTypes List
+router.get(
+  "/contentTypes/:projectId/:skip/:limit/:searchText?",
+  asyncRouter(contentMapperController.getContentTypes)
+);
+//Get FieldMapping List
+router.get(
+  "/fieldMappnig/:contentTypeId/:skip/:limit/:searchText?",
+  asyncRouter(contentMapperController.getFieldMapping)
+);
+//Get Existing ContentTypes List
+//To Do
+router.get(
+  "/:projectId/:stackUid",
+  asyncRouter(contentMapperController.getExistingContentTypes)
+);
+//Update FieldMapping or contentType
+router.put(
+  "/contentTypes/:contentTypeId",
+  asyncRouter(contentMapperController.putContentTypeFields)
+);
+//Reset FieldMapping or contentType
+router.put(
+  "/resetFields/:contentTypeId",
+  asyncRouter(contentMapperController.resetContentType)
+);
+
+export default router;

src/server.ts

@@ -14,6 +14,7 @@ import { authenticateUser } from "./middlewares/auth.middleware";
 import { requestHeadersMiddleware } from "./middlewares/req-headers.middleware";
 import { unmatchedRoutesMiddleware } from "./middlewares/unmatched-routes.middleware";
 import logger from "./utils/logger";
+import contentMapperRoutes from "./routes/contentMapper.routes";
 
 try {
   const app = express();
@@ -34,6 +35,7 @@ try {
   app.use("/v2/user", authenticateUser, userRoutes);
   app.use("/v2/org/:orgId", authenticateUser, orgRoutes);
   app.use("/v2/org/:orgId/project", authenticateUser, projectRoutes);
+  app.use("/v2/mapper", authenticateUser, contentMapperRoutes);
 
   //For unmatched route patterns
   app.use(unmatchedRoutesMiddleware);