feat: add support for AM in import module

packages/contentstack-asset-management/src/constants/index.ts

@@ -1,6 +1,20 @@
 export const BATCH_SIZE = 50;
 export const CHUNK_FILE_SIZE_MB = 1;
 
+/** Default parallel AM API calls when import caller does not set apiConcurrency. */
+export const DEFAULT_AM_API_CONCURRENCY = 5;
+
+/**
+ * Mapper output paths — must stay aligned with contentstack-import `PATH_CONSTANTS`
+ * (`mapper` / `assets` / uid, url, space-uid file names).
+ */
+export const IMPORT_ASSETS_MAPPER_DIR_SEGMENTS = ['mapper', 'assets'] as const;
+export const IMPORT_ASSETS_MAPPER_FILES = {
+  UID_MAPPING: 'uid-mapping.json',
+  URL_MAPPING: 'url-mapping.json',
+  SPACE_UID_MAPPING: 'space-uid-mapping.json',
+} as const;
+
 /**
  * Main process name for Asset Management 2.0 export (single progress bar).
  * Use this when adding/starting the process and for all ticks.
@@ -17,10 +31,15 @@ export const PROCESS_NAMES = {
   AM_FIELDS: 'Fields',
   AM_ASSET_TYPES: 'Asset types',
   AM_DOWNLOADS: 'Asset downloads',
+  // Import process names
+  AM_IMPORT_FIELDS: 'Import fields',
+  AM_IMPORT_ASSET_TYPES: 'Import asset types',
+  AM_IMPORT_FOLDERS: 'Import folders',
+  AM_IMPORT_ASSETS: 'Import assets',
 } as const;
 
 /**
- * Status messages for each process (exporting, fetching, failed).
+ * Status messages for each process (exporting, fetching, importing, failed).
  */
 export const PROCESS_STATUS = {
   [PROCESS_NAMES.AM_SPACE_METADATA]: {
@@ -47,4 +66,20 @@ export const PROCESS_STATUS = {
     DOWNLOADING: 'Downloading asset files...',
     FAILED: 'Failed to download assets.',
   },
+  [PROCESS_NAMES.AM_IMPORT_FIELDS]: {
+    IMPORTING: 'Importing shared fields...',
+    FAILED: 'Failed to import fields.',
+  },
+  [PROCESS_NAMES.AM_IMPORT_ASSET_TYPES]: {
+    IMPORTING: 'Importing shared asset types...',
+    FAILED: 'Failed to import asset types.',
+  },
+  [PROCESS_NAMES.AM_IMPORT_FOLDERS]: {
+    IMPORTING: 'Importing folders...',
+    FAILED: 'Failed to import folders.',
+  },
+  [PROCESS_NAMES.AM_IMPORT_ASSETS]: {
+    IMPORTING: 'Importing assets...',
+    FAILED: 'Failed to import assets.',
+  },
 } as const;

packages/contentstack-asset-management/src/export/assets.ts

@@ -21,8 +21,8 @@ export default class ExportAssets extends AssetManagementExportAdapter {
     log.debug(`Fetching folders and assets for space ${workspace.space_uid}`, this.exportContext.context);
 
     const [folders, assetsData] = await Promise.all([
-      this.getWorkspaceFolders(workspace.space_uid),
-      this.getWorkspaceAssets(workspace.space_uid),
+      this.getWorkspaceFolders(workspace.space_uid, workspace.uid),
+      this.getWorkspaceAssets(workspace.space_uid, workspace.uid),
     ]);
 
     await writeFile(pResolve(assetsDir, 'folders.json'), JSON.stringify(folders, null, 2));

packages/contentstack-asset-management/src/export/spaces.ts

@@ -29,15 +29,8 @@ export class ExportSpaces {
   }
 
   async start(): Promise<void> {
-    const {
-      linkedWorkspaces,
-      exportDir,
-      branchName,
-      assetManagementUrl,
-      org_uid,
-      context,
-      securedAssets,
-    } = this.options;
+    const { linkedWorkspaces, exportDir, branchName, assetManagementUrl, org_uid, apiKey, context, securedAssets } =
+      this.options;
 
     if (!linkedWorkspaces.length) {
       log.debug('No linked workspaces to export', context);
@@ -54,7 +47,9 @@ export class ExportSpaces {
     const totalSteps = 2 + linkedWorkspaces.length * 4;
     const progress = this.createProgress();
     progress.addProcess(AM_MAIN_PROCESS_NAME, totalSteps);
-    progress.startProcess(AM_MAIN_PROCESS_NAME).updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_FIELDS].FETCHING, AM_MAIN_PROCESS_NAME);
+    progress
+      .startProcess(AM_MAIN_PROCESS_NAME)
+      .updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_FIELDS].FETCHING, AM_MAIN_PROCESS_NAME);
 
     const apiConfig: AssetManagementAPIConfig = {
       baseURL: assetManagementUrl,

packages/contentstack-asset-management/src/import/asset-types.ts

@@ -0,0 +1,100 @@
+import omit from 'lodash/omit';
+import isEqual from 'lodash/isEqual';
+import { log } from '@contentstack/cli-utilities';
+
+import type { AssetManagementAPIConfig, ImportContext } from '../types/asset-management-api';
+import { AssetManagementImportAdapter } from './base';
+import { PROCESS_NAMES, PROCESS_STATUS } from '../constants/index';
+import { runInBatches } from '../utils/concurrent-batch';
+
+const STRIP_KEYS = ['created_at', 'created_by', 'updated_at', 'updated_by', 'is_system', 'category', 'preview_image_url', 'category_detail'];
+
+/**
+ * Reads shared asset types from `spaces/asset_types/asset-types.json` and POSTs
+ * each to the target org-level AM endpoint (`POST /api/asset_types`).
+ *
+ * Strategy: Fetch → Diff → Create only missing, warn on conflict
+ * 1. Fetch asset types that already exist in the target org.
+ * 2. Skip entries where is_system=true (platform-owned, cannot be created via API).
+ * 3. If uid already exists and definition differs → warn and skip.
+ * 4. If uid already exists and definition matches → silently skip.
+ * 5. Strip read-only/computed keys from the POST body before creating new asset types.
+ */
+export default class ImportAssetTypes extends AssetManagementImportAdapter {
+  constructor(apiConfig: AssetManagementAPIConfig, importContext: ImportContext) {
+    super(apiConfig, importContext);
+  }
+
+  async start(): Promise<void> {
+    await this.init();
+
+    const dir = this.getAssetTypesDir();
+    const items = await this.readAllChunkedJson<Record<string, unknown>>(dir, 'asset-types.json');
+
+    if (items.length === 0) {
+      log.debug('No shared asset types to import', this.importContext.context);
+      return;
+    }
+
+    // Fetch existing asset types from the target org keyed by uid for diff comparison.
+    // Asset types are org-level; the spaceUid param in getWorkspaceAssetTypes is unused in the path.
+    const existingByUid = new Map<string, Record<string, unknown>>();
+    try {
+      const existing = await this.getWorkspaceAssetTypes('');
+      for (const at of existing.asset_types ?? []) {
+        existingByUid.set(at.uid, at as Record<string, unknown>);
+      }
+      log.debug(`Target org has ${existingByUid.size} existing asset type(s)`, this.importContext.context);
+    } catch (e) {
+      log.debug(`Could not fetch existing asset types, will attempt to create all: ${e}`, this.importContext.context);
+    }
+
+    this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSET_TYPES].IMPORTING, PROCESS_NAMES.AM_IMPORT_ASSET_TYPES);
+
+    type ToCreate = { uid: string; payload: Record<string, unknown> };
+    const toCreate: ToCreate[] = [];
+
+    for (const assetType of items) {
+      const uid = assetType.uid as string;
+
+      if (assetType.is_system) {
+        log.debug(`Skipping system asset type: ${uid}`, this.importContext.context);
+        continue;
+      }
+
+      const existing = existingByUid.get(uid);
+      if (existing) {
+        const exportedClean = omit(assetType, STRIP_KEYS);
+        const existingClean = omit(existing, STRIP_KEYS);
+        if (!isEqual(exportedClean, existingClean)) {
+          log.warn(
+            `Asset type "${uid}" already exists in the target org with a different definition. Skipping — to apply the exported definition, delete the asset type from the target org first.`,
+            this.importContext.context,
+          );
+        } else {
+          log.debug(`Asset type "${uid}" already exists with matching definition, skipping`, this.importContext.context);
+        }
+        this.tick(true, `asset-type: ${uid} (skipped, already exists)`, null, PROCESS_NAMES.AM_IMPORT_ASSET_TYPES);
+        continue;
+      }
+
+      toCreate.push({ uid, payload: omit(assetType, STRIP_KEYS) as Record<string, unknown> });
+    }
+
+    await runInBatches(toCreate, this.apiConcurrency, async ({ uid, payload }) => {
+      try {
+        await this.createAssetType(payload as any);
+        this.tick(true, `asset-type: ${uid}`, null, PROCESS_NAMES.AM_IMPORT_ASSET_TYPES);
+        log.debug(`Imported asset type: ${uid}`, this.importContext.context);
+      } catch (e) {
+        this.tick(
+          false,
+          `asset-type: ${uid}`,
+          (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSET_TYPES].FAILED,
+          PROCESS_NAMES.AM_IMPORT_ASSET_TYPES,
+        );
+        log.debug(`Failed to import asset type ${uid}: ${e}`, this.importContext.context);
+      }
+    });
+  }
+}