Merge pull request #1037 from contentstack/feature/cmg-774

Feature/cmg 774

Author: umeshmore45

api/package-lock.json

@@ -35,7 +35,7 @@
     "@contentstack/json-rte-serializer": "^3.0.5",
     "@contentstack/marketplace-sdk": "^1.5.0",
     "@wordpress/block-serialization-default-parser": "^5.39.0",
-    "axios": "^1.13.5",
+    "axios": "^1.15.0",
     "cheerio": "^1.2.0",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",
@@ -91,6 +91,9 @@
     "vitest": "^4.0.18"
   },
   "overrides": {
+    "@contentstack/cli-utilities": {
+      "axios": ">=1.15.0"
+    },
     "qs": ">=6.14.2",
     "tmp": ">=0.2.4",
     "minimatch": ">=10.2.3",

api/package.json

@@ -1581,6 +1581,75 @@ const getExistingTaxonomies = async (req: Request) => {
     };
   }
 };
+const getExistingExtensions = async ({existingStackId, token_payload}: any) => {
+  try {
+    const url = `${config?.CS_API[
+      token_payload?.region as keyof typeof config.CS_API
+    ]!}/extensions`;
+
+    const headers: Record<string, string> = { api_key: existingStackId };
+    if (token_payload?.is_sso) {
+      const accessToken = await getAccessToken(
+        token_payload?.region,
+        token_payload?.user_id,
+      );
+      headers.authorization = `Bearer ${accessToken}`;
+    } else {
+      headers.authtoken = await getAuthtoken(
+        token_payload?.region,
+        token_payload?.user_id,
+      );
+    }
+
+    const requestConfig = {
+      method: 'GET' as const,
+      url,
+      headers,
+    };
+
+    const [err, res] = token_payload?.is_sso
+      ? await requestWithSsoTokenRefresh(token_payload, requestConfig)
+      : await safePromise(https(requestConfig));
+
+    if (err) {
+      const e = err as {
+        message?: string;
+        response?: { status?: number; data?: unknown };
+      };
+      const detail =
+        e.response?.data != null
+          ? typeof e.response.data === 'string'
+            ? e.response.data
+            : JSON.stringify(e.response.data)
+          : e.message;
+      const httpErr = new Error(`Error in getExistingExtensions: ${detail}`);
+      if (e.response?.status != null) {
+        Object.assign(httpErr, { statusCode: e.response.status });
+      }
+      throw httpErr;
+    }
+
+    const extensions = res?.data?.extensions;
+    console.info('extensions', extensions);
+    if (!Array.isArray(extensions)) {
+      throw new Error(
+        'Error in getExistingExtensions: extensions is not an array',
+      );
+    }
+
+    return extensions.filter((ext: { type?: string }) => ext?.type === 'field');
+
+  } catch (error: any) {
+    logger.error(`Error in getExistingExtensions: ${error.message}`, error);
+    return {
+      data: error?.message,
+      status: error?.statusCode || error?.status || 500,
+    };
+
+    
+  }
+
+}
 
 export const contentMapperService = {
   putTestData,
@@ -1597,4 +1666,5 @@ export const contentMapperService = {
   getExistingGlobalFields,
   getSingleGlobalField,
   getExistingTaxonomies,
+  getExistingExtensions,
 };

api/src/services/contentMapper.service.ts

@@ -6,7 +6,7 @@ import customLogger from '../../utils/custom-logger.utils.js';
 import { getLogMessage } from '../../utils/index.js';
 import { MIGRATION_DATA_CONFIG } from '../../constants/index.js';
 
-const { DATA, TAXONOMIES_DIR_NAME } = MIGRATION_DATA_CONFIG;
+const { DATA, TAXONOMIES_DIR_NAME, TAXONOMIES_FILE_NAME} = MIGRATION_DATA_CONFIG;
 
 interface DrupalTaxonomyTerm {
   taxonomy_uid: string; // vid (vocabulary id)
@@ -331,18 +331,34 @@ const saveTaxonomyFiles = async (
       };
     }
 
-    const taxonomiesFilePath = path.join(taxonomiesPath, 'taxonomies.json');
+    const taxonomiesFilePath = path.join(taxonomiesPath, TAXONOMIES_FILE_NAME);
+    let mergedTaxonomiesMeta: Record<string, any> = { ...taxonomiesDataObject };
+
+    if (fs.existsSync(taxonomiesFilePath)) {
+      try {
+        const existingRaw = await fs.promises.readFile(taxonomiesFilePath, 'utf8');
+        const existing = JSON.parse(existingRaw) as Record<string, any>;
+        if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+          mergedTaxonomiesMeta = { ...existing, ...taxonomiesDataObject };
+        }
+      } catch {
+        mergedTaxonomiesMeta = { ...taxonomiesDataObject };
+      }
+    }
+
     await fs.promises.writeFile(
       taxonomiesFilePath,
-      JSON.stringify(taxonomiesDataObject, null, 2),
+      JSON.stringify(mergedTaxonomiesMeta, null, 2),
       'utf8'
     );
 
     const consolidatedMessage = getLogMessage(
       srcFunc,
       `Saved consolidated taxonomies.json with ${
-        Object.keys(taxonomiesDataObject).length
-      } vocabularies.`,
+        Object.keys(mergedTaxonomiesMeta)?.length
+      } vocabularies (${
+        Object.keys(taxonomiesDataObject)?.length
+      } from this run).`,
       {}
     );
     await customLogger(
@@ -393,7 +409,9 @@ export const createTaxonomy = async (
     );
 
     // Create taxonomies directory
-    await fs.promises.mkdir(taxonomiesPath, { recursive: true });
+    if(!fs.existsSync(taxonomiesPath)){
+      await fs.promises.mkdir(taxonomiesPath, { recursive: true });
+    }
 
     const message = getLogMessage(srcFunc, `Exporting taxonomies...`, {});
     await customLogger(projectId, destination_stack_id, 'info', message);

api/src/services/drupal/taxonomy.service.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import fs from 'fs';
 import { MIGRATION_DATA_CONFIG, LIST_EXTENSION_UID } from "../constants/index.js";
+import { contentMapperService } from "./contentMapper.service.js";
 
 const {
   CUSTOM_MAPPER_FILE_NAME,
@@ -27,6 +28,26 @@ const writeExtFile = async ({ destinationStackId, extensionData }: any) => {
     console.error("🚀 ~ fs.writeFile ~ err:", writeErr);
   }
 }
+const formatExtensionData = (extension: any, destinationStackId: string) => {
+      return  {
+        "stackHeaders": { "api_key": destinationStackId },
+        "urlPath": `/extensions/${extension?.uid}`,
+        "uid": extension?.uid,
+        "created_at": extension?.created_at,
+        "updated_at": extension?.updated_at,
+        "created_by": extension?.created_by,
+        "updated_by": extension?.updated_by,
+        "tags": extension?.tags,
+        "_version": extension?._version,
+        "title": extension?.title,
+        "config": extension?.config,
+        "type": extension?.type,
+        "data_type": extension?.data_type,
+        "multiple": extension?.multiple,
+        "srcdoc": extension?.srcdoc,
+    
+    }
+}
 
 const getExtension = ({ uid, destinationStackId }: any) => {
   if (uid === LIST_EXTENSION_UID) {
@@ -50,8 +71,12 @@ const getExtension = ({ uid, destinationStackId }: any) => {
   }
   return null;
 }
+const getExsitingExtension = async ({ existingStackId, token_payload }: any) => {
+  const result = await contentMapperService.getExistingExtensions({ existingStackId, token_payload});
+  return result;
+}
 
-const createExtension = async ({ destinationStackId }: any) => {
+const createExtension = async ({ destinationStackId, existingStackId, token_payload }: any) => {
   const extensionPath = path.join(MIGRATION_DATA_CONFIG.DATA, destinationStackId, CUSTOM_MAPPER_FILE_NAME);
   const extMapper: any = await fs.promises.readFile(extensionPath, "utf-8").catch(async () => { });
   if (extMapper !== undefined) {
@@ -66,6 +91,21 @@ const createExtension = async ({ destinationStackId }: any) => {
     }
     await writeExtFile({ destinationStackId, extensionData })
   }
+  else{
+    const existingExtension = await getExsitingExtension({ existingStackId, token_payload });
+    if (existingExtension && Array?.isArray(existingExtension)) {
+      const extensionData: any = {};
+      for await (const extension of existingExtension) {
+        const extData =  formatExtensionData(extension, destinationStackId );
+        if (extData) {
+          extensionData[extension?.uid] = extension;
+        }
+      }
+      await writeExtFile({ destinationStackId, extensionData })
+      
+    }
+ 
+  }
 }
 
 

api/src/services/extension.service.ts

@@ -425,15 +425,21 @@ const startTestMigration = async (req: Request): Promise<any> => {
     });
     await extensionService?.createExtension({
       destinationStackId: project?.current_test_stack_id,
+      existingStackId: project?.destination_stack_id,
+      token_payload: {
+        region,
+        user_id,
+        is_sso,
+      },
+    });
+    await taxonomyService?.createTaxonomy({
+      orgId,
+      projectId,
+      stackId: project?.destination_stack_id,
+      current_test_stack_id: project?.current_test_stack_id,
+      region,
+      userId: user_id,
     });
-    // await taxonomyService?.createTaxonomy({
-    //   orgId,
-    //   projectId,
-    //   stackId: project?.destination_stack_id,
-    //   current_test_stack_id: project?.current_test_stack_id,
-    //   region,
-    //   userId: user_id,
-    // });
     await globalFieldServie?.createGlobalField({
       region,
       user_id,
@@ -819,6 +825,12 @@ const startMigration = async (req: Request): Promise<any> => {
     });
     await extensionService?.createExtension({
       destinationStackId: project?.destination_stack_id,
+      existingStackId: project?.source_stack_id,
+      token_payload: {
+        region,
+        user_id,
+        is_sso,
+      },
     });
     await taxonomyService?.createTaxonomy({
       orgId,

api/src/services/migration.service.ts

@@ -1151,7 +1151,12 @@ const mergeTwoCts = async (ct: any, mergeCts: any) => {
     title: mergeCts?.title,
     uid: mergeCts?.uid,
     options: {
+      is_page: true,
       "singleton": false,
+      title: "title",
+      url_pattern: '/:title',
+      url_prefix: `/`,
+      sub_title: ['url']
     }
   }
 

api/src/utils/content-type-creator.utils.ts

@@ -83,6 +83,14 @@ describe('projects.contentMapper.controller', () => {
     expect(res.status).toHaveBeenCalledWith(200);
   });
 
+  it('getExistingTaxonomies should default to 200 when status is omitted', async () => {
+    mockContentMapperService.getExistingTaxonomies.mockResolvedValue({ taxonomies: [] });
+
+    await contentMapperController.getExistingTaxonomies(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(200);
+  });
+
   it('getSingleContentTypes should return 201', async () => {
     mockContentMapperService.getSingleContentTypes.mockResolvedValue({ title: 'Blog' });
 

api/tests/unit/controllers/projects.contentMapper.controller.test.ts

@@ -16,7 +16,16 @@ const {
 vi.mock('fs', () => ({
   default: { promises: mockFsPromises },
 }));
-vi.mock('path', () => ({ default: { join: mockPathJoin } }));
+vi.mock('path', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('path')>();
+  return {
+    ...actual,
+    default: {
+      ...actual.default,
+      join: mockPathJoin,
+    },
+  };
+});
 vi.mock('../../../src/constants/index.js', () => ({
   MIGRATION_DATA_CONFIG: {
     DATA: './cmsMigrationData',