merged latest code

Author: shafeeqd959

.talismanrc

@@ -16,11 +16,17 @@ fileignoreconfig:
   - filename: packages/contentstack-import/src/import/modules/publishing-rules.ts
     checksum: 429a803bc18e691db93bae3df1714071d0face6441b82cb938a83e8bf94ae14c
   - filename: packages/contentstack-import/src/types/default-config.ts
-    checksum: 84589b06580c88dc6722abd663c4b7bb352d1bcfa1f870f4237f6f97b2166f3d
+    checksum: c117d060d6979540a1bb6ae20ad6ad6d43e9b15a6909291f76ed60b11e5f793d
   - filename: packages/contentstack-import/test/unit/import/modules/publishing-rules.test.ts
     checksum: 0fcbff5dab2f9e594fe2a316c3c96e8d86bcd5d72e7c1f9eb35c0e3458f87817
   - filename: packages/contentstack-export/src/types/default-config.ts
     checksum: 70c9ca7400c447f2b54f48a07965c7ba34706deee97d68951d6229d523c7e4b0
   - filename: packages/contentstack-export/src/types/index.ts
-    checksum: 4d895dc8355b94847e3e1746d65eb51d5b9434de307ddcd91c0a33083b97b9ef
+    checksum: 71f02ac11507c61222a661caf228dfd54ffdc6c57e4cc631f66598ecd617852b
+  - filename: packages/contentstack-import/test/unit/utils/build-import-spaces-options.test.ts
+    checksum: ecc39327ca93ca4ea749937ec853f5a4c9a609a96c4e4e15df1b596fb4f32c74
+  - filename: packages/contentstack-asset-management/test/unit/import/workspaces.test.ts
+    checksum: a0a17ff803fcf8f20538c8e158909d06705fc801f0bd3356b1eac1d92f006d83
+  - filename: packages/contentstack-asset-management/test/unit/import/spaces.test.ts
+    checksum: 163c7e519561f2c1f473f6f0c5303a2a47c9f5c231b638cd90782c37eaa4859e
 version: '1.0'

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

@@ -158,7 +158,14 @@ export class ImportSpaces {
         try {
           const workspaceImporter = new ImportWorkspace(apiConfig, importContext);
           workspaceImporter.setParentProgressManager(progress);
-          const result = await workspaceImporter.start(spaceUid, spaceDir, existingSpaceUids, spaceProcess);
+          const result = await workspaceImporter.start(
+            spaceUid,
+            spaceDir,
+            existingSpaceUids,
+            spaceProcess,
+            configOptions.targetDefaultSpaceUid,
+            configOptions.targetDefaultWorkspaceUid,
+          );
 
           // Newly created spaces get a new uid — add so later iterations in this run see it.
           existingSpaceUids.add(result.newSpaceUid);

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

@@ -35,6 +35,8 @@ export default class ImportWorkspace extends CSAssetsImportAdapter {
     spaceDir: string,
     existingSpaceUids: Set<string> = new Set(),
     spaceProcessName?: string,
+    targetDefaultSpaceUid?: string,
+    targetDefaultWorkspaceUid?: string,
   ): Promise<WorkspaceResult> {
     await this.init();
 
@@ -64,6 +66,20 @@ export default class ImportWorkspace extends CSAssetsImportAdapter {
       assetsImporter.setProcessName(spaceProcessName);
     }
 
+    // Map source default space → existing target default space (cross-org migration).
+    // The caller supplies the uid of the pre-existing target default space; we upload
+    // source assets into it instead of creating a new space.
+    if (isDefault && targetDefaultSpaceUid) {
+      const newSpaceUid = targetDefaultSpaceUid;
+      const resolvedWorkspaceUid = targetDefaultWorkspaceUid ?? workspaceUid;
+      log.info(
+        `Source default space "${oldSpaceUid}" mapped to existing target default space "${newSpaceUid}".`,
+        this.importContext.context,
+      );
+      const { uidMap, urlMap } = await assetsImporter.start(newSpaceUid, spaceDir);
+      return { oldSpaceUid, newSpaceUid, workspaceUid: resolvedWorkspaceUid, isDefault: true, uidMap, urlMap };
+    }
+
     // Reuse: target org already has a space with the same uid as the export directory.
     if (existingSpaceUids.has(oldSpaceUid)) {
       log.info(

packages/contentstack-asset-management/src/types/cs-assets-api.ts

@@ -243,6 +243,16 @@ export type ImportSpacesOptions = {
   mapperUidFileName?: string;
   mapperUrlFileName?: string;
   mapperSpaceUidFileName?: string;
+  /**
+   * UID of the already-existing default space in the target org.
+   * When set, the source default space is imported into this space instead of creating a new one.
+   */
+  targetDefaultSpaceUid?: string;
+  /**
+   * Workspace link UID of the existing default workspace in the target branch's `am_v2.linked_workspaces`.
+   * Returned in SpaceMapping.workspaceUid so downstream branch-linking logic can identify the entry correctly.
+   */
+  targetDefaultWorkspaceUid?: string;
 };
 
 /**

packages/contentstack-asset-management/test/unit/import/spaces.test.ts

@@ -0,0 +1,176 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { CLIProgressManager, configHandler } from '@contentstack/cli-utilities';
+
+import { ImportSpaces } from '../../../src/import/spaces';
+import ImportWorkspace from '../../../src/import/workspaces';
+import ImportFields from '../../../src/import/fields';
+import ImportAssetTypes from '../../../src/import/asset-types';
+import { CSAssetsAdapter } from '../../../src/utils/cs-assets-api-adapter';
+import { CSAssetsImportAdapter } from '../../../src/import/base';
+import { PROCESS_NAMES } from '../../../src/constants/index';
+
+import type { ImportSpacesOptions } from '../../../src/types/cs-assets-api';
+
+describe('ImportSpaces', () => {
+  const baseOptions: ImportSpacesOptions = {
+    contentDir: '/tmp/import',
+    csAssetsUrl: 'https://am.example.com',
+    org_uid: 'org-1',
+    apiKey: 'api-key-1',
+    host: 'https://api.contentstack.io/v3',
+  };
+
+  const fakeProgress = {
+    addProcess: sinon.stub().returnsThis(),
+    startProcess: sinon.stub().returnsThis(),
+    updateStatus: sinon.stub().returnsThis(),
+    tick: sinon.stub(),
+    completeProcess: sinon.stub(),
+  };
+
+  beforeEach(() => {
+    sinon.stub(configHandler, 'get').returns({ showConsoleLogs: false });
+    sinon.stub(CLIProgressManager, 'createNested').returns(fakeProgress as any);
+    // init and listSpaces live on AssetManagementAdapter (the common base).
+    // Stubbing the base once covers both the adapter used for listSpaces and ImportWorkspace.
+    sinon.stub(CSAssetsAdapter.prototype, 'init' as any).resolves();
+    sinon.stub(CSAssetsAdapter.prototype, 'listSpaces' as any).resolves({ spaces: [] });
+    sinon.stub(ImportFields.prototype, 'start').resolves();
+    sinon.stub(ImportFields.prototype, 'setParentProgressManager');
+    sinon.stub(ImportAssetTypes.prototype, 'start').resolves();
+    sinon.stub(ImportAssetTypes.prototype, 'setParentProgressManager');
+    sinon.stub(ImportWorkspace.prototype, 'setParentProgressManager');
+
+    fakeProgress.addProcess.resetHistory();
+    fakeProgress.addProcess.returnsThis();
+    fakeProgress.startProcess.resetHistory();
+    fakeProgress.startProcess.returnsThis();
+    fakeProgress.completeProcess.reset();
+    fakeProgress.tick.reset();
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const stubSpaceDirs = (dirs: string[]) => {
+    const fsMock = require('node:fs');
+    sinon.stub(fsMock, 'readdirSync').returns(dirs as any);
+    sinon.stub(fsMock, 'statSync').returns({ isDirectory: () => true } as any);
+  };
+
+  describe('targetDefaultSpaceUid threading', () => {
+    it('should pass targetDefaultSpaceUid and targetDefaultWorkspaceUid to ImportWorkspace.start()', async () => {
+      stubSpaceDirs(['am-space-1']);
+      const startStub = sinon.stub(ImportWorkspace.prototype, 'start').resolves({
+        oldSpaceUid: 'am-space-1',
+        newSpaceUid: 'target-space-3',
+        workspaceUid: 'ws-3',
+        isDefault: true,
+        uidMap: {},
+        urlMap: {},
+      });
+
+      const options: ImportSpacesOptions = {
+        ...baseOptions,
+        targetDefaultSpaceUid: 'target-space-3',
+        targetDefaultWorkspaceUid: 'ws-3',
+      };
+      const importer = new ImportSpaces(options);
+      await importer.start();
+
+      expect(startStub.callCount).to.equal(1);
+      const args = startStub.firstCall.args;
+      expect(args[4]).to.equal('target-space-3');
+      expect(args[5]).to.equal('ws-3');
+    });
+
+    it('should pass undefined to ImportWorkspace when targetDefaultSpaceUid is not set', async () => {
+      stubSpaceDirs(['am-space-1']);
+      const startStub = sinon.stub(ImportWorkspace.prototype, 'start').resolves({
+        oldSpaceUid: 'am-space-1',
+        newSpaceUid: 'new-space',
+        workspaceUid: 'main',
+        isDefault: false,
+        uidMap: {},
+        urlMap: {},
+      });
+
+      const importer = new ImportSpaces(baseOptions);
+      await importer.start();
+
+      expect(startStub.callCount).to.equal(1);
+      expect(startStub.firstCall.args[4]).to.be.undefined;
+      expect(startStub.firstCall.args[5]).to.be.undefined;
+    });
+
+    it('should record the correct spaceUidMap entry when default space is remapped', async () => {
+      stubSpaceDirs(['am-space-1']);
+      sinon.stub(ImportWorkspace.prototype, 'start').resolves({
+        oldSpaceUid: 'am-space-1',
+        newSpaceUid: 'target-space-3',
+        workspaceUid: 'ws-3',
+        isDefault: true,
+        uidMap: {},
+        urlMap: {},
+      });
+
+      const options: ImportSpacesOptions = {
+        ...baseOptions,
+        targetDefaultSpaceUid: 'target-space-3',
+      };
+      const importer = new ImportSpaces(options);
+      const result = await importer.start();
+
+      expect(result.spaceUidMap['am-space-1']).to.equal('target-space-3');
+      expect(result.spaceMappings[0].newSpaceUid).to.equal('target-space-3');
+      expect(result.spaceMappings[0].isDefault).to.equal(true);
+    });
+
+    it('should process non-default spaces normally alongside the remapped default space', async () => {
+      stubSpaceDirs(['am-space-1', 'am-space-2']);
+      const startStub = sinon.stub(ImportWorkspace.prototype, 'start');
+      startStub.onFirstCall().resolves({
+        oldSpaceUid: 'am-space-1',
+        newSpaceUid: 'target-space-3',
+        workspaceUid: 'ws-3',
+        isDefault: true,
+        uidMap: {},
+        urlMap: {},
+      });
+      startStub.onSecondCall().resolves({
+        oldSpaceUid: 'am-space-2',
+        newSpaceUid: 'brand-new-space',
+        workspaceUid: 'main',
+        isDefault: false,
+        uidMap: {},
+        urlMap: {},
+      });
+
+      const options: ImportSpacesOptions = {
+        ...baseOptions,
+        targetDefaultSpaceUid: 'target-space-3',
+        targetDefaultWorkspaceUid: 'ws-3',
+      };
+      const importer = new ImportSpaces(options);
+      const result = await importer.start();
+
+      expect(result.spaceMappings).to.have.lengthOf(2);
+      expect(result.spaceUidMap['am-space-1']).to.equal('target-space-3');
+      expect(result.spaceUidMap['am-space-2']).to.equal('brand-new-space');
+    });
+  });
+
+  describe('no spaces scenario', () => {
+    it('should return empty maps when spaces directory has no am* dirs', async () => {
+      stubSpaceDirs([]);
+
+      const importer = new ImportSpaces(baseOptions);
+      const result = await importer.start();
+
+      expect(result.spaceMappings).to.deep.equal([]);
+      expect(result.spaceUidMap).to.deep.equal({});
+    });
+  });
+});