@kontent-ai/migration-toolkit 1.0.0

package/lib/import/importers/language-variant-importer.ts

@@ -0,0 +1,342 @@
+import {
+    ContentItemModels,
+    ElementContracts,
+    LanguageVariantModels,
+    ManagementClient,
+    WorkflowModels
+} from '@kontent-ai/management-sdk';
+import {
+    Logger,
+    processItemsAsync,
+    runMapiRequestAsync,
+    MigrationItem,
+    LogSpinnerData,
+    MigrationElement,
+    MigrationItemVersion,
+    workflowHelper,
+    findRequired
+} from '../../core/index.js';
+import chalk from 'chalk';
+import { ImportContext } from '../import.models.js';
+import { importTransforms } from '../../translation/index.js';
+import { workflowImporter } from './workflow-importer.js';
+import { throwErrorForMigrationItem } from '../utils/import.utils.js';
+
+export function languageVariantImporter(config: {
+    readonly logger: Logger;
+    readonly preparedContentItems: readonly ContentItemModels.ContentItem[];
+    readonly importContext: ImportContext;
+    readonly client: Readonly<ManagementClient>;
+}) {
+    const upsertLanguageVariantAsync = async (data: {
+        readonly workflow: Readonly<WorkflowModels.Workflow>;
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly migrationItemVersion: MigrationItemVersion;
+        readonly preparedContentItem: Readonly<ContentItemModels.ContentItem>;
+    }): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant>> => {
+        return await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () => {
+                return (
+                    await config.client
+                        .upsertLanguageVariant()
+                        .byItemCodename(data.preparedContentItem.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withData(() => {
+                            return {
+                                elements: Object.entries(data.migrationItemVersion.elements).map(
+                                    ([codename, migrationElement]) => {
+                                        return getElementContract(data.migrationItem, migrationElement, codename);
+                                    }
+                                ),
+                                workflow: {
+                                    workflow_identifier: {
+                                        codename: data.workflow.codename
+                                    },
+                                    step_identifier: {
+                                        codename: data.workflow.steps[0].codename // use always first step
+                                    }
+                                }
+                            };
+                        })
+                        .toPromise()
+                ).data;
+            },
+            action: 'upsert',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename})`
+        });
+    };
+
+    const categorizeVersions = (
+        migrationItem: MigrationItem
+    ): { publishedVersion: MigrationItemVersion | undefined; draftVersion: MigrationItemVersion | undefined } => {
+        const workflow = workflowHelper(config.importContext.environmentData.workflows).getWorkflowByCodename(
+            migrationItem.system.workflow.codename
+        );
+
+        const publishedVersions = migrationItem.versions.filter((version) =>
+            isPublishedWorkflowStep(version.workflow_step.codename, workflow)
+        );
+        const draftVersions = migrationItem.versions.filter(
+            (version) => !isPublishedWorkflowStep(version.workflow_step.codename, workflow)
+        );
+
+        if (publishedVersions.length > 1) {
+            throwErrorForMigrationItem(
+                migrationItem,
+                `There can be only 1 published version. There are '${publishedVersions.length}' published versions for the item.`
+            );
+        }
+
+        if (draftVersions.length > 1) {
+            throwErrorForMigrationItem(
+                migrationItem,
+                `There can be only 1 draft version. There are '${publishedVersions.length}' draft versions for the item.`
+            );
+        }
+
+        return {
+            draftVersion: draftVersions?.[0],
+            publishedVersion: publishedVersions?.[0]
+        };
+    };
+
+    const importVersionAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly migrationItemVersion: MigrationItemVersion;
+        readonly preparedContentItem: Readonly<ContentItemModels.ContentItem>;
+        readonly workflowStepCodenameInTargetEnvironment: string | undefined;
+    }): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant>> => {
+        // validate workflow
+        const { step, workflow } = workflowHelper(
+            config.importContext.environmentData.workflows
+        ).getWorkflowAndStepByCodenames({
+            workflowCodename: data.migrationItem.system.workflow.codename,
+            stepCodename: data.migrationItemVersion.workflow_step.codename
+        });
+
+        // prepare target variant for upsert if it exists in target env
+        if (data.workflowStepCodenameInTargetEnvironment) {
+            await prepareLanguageVariantForImportAsync({
+                logSpinner: data.logSpinner,
+                workflowStepCodenameInTargetEnvironment: data.workflowStepCodenameInTargetEnvironment,
+                migrationItem: data.migrationItem,
+                workflow
+            });
+        }
+
+        // upsert language variant
+        const languageVariant = await upsertLanguageVariantAsync({
+            logSpinner: data.logSpinner,
+            migrationItem: data.migrationItem,
+            preparedContentItem: data.preparedContentItem,
+            migrationItemVersion: data.migrationItemVersion,
+            workflow
+        });
+
+        // set workflow accordingly (publish, move to workflow step, archive ...)
+        await workflowImporter({
+            logger: config.logger,
+            managementClient: config.client,
+            workflows: config.importContext.environmentData.workflows
+        }).setWorkflowOfLanguageVariantAsync({
+            logSpinner: data.logSpinner,
+            migrationItem: data.migrationItem,
+            workflowCodename: workflow.codename,
+            stepCodename: step.codename
+        });
+
+        return languageVariant;
+    };
+
+    const importLanguageVariantAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationItem: MigrationItem,
+        preparedContentItem: Readonly<ContentItemModels.ContentItem>
+    ): Promise<readonly LanguageVariantModels.ContentItemLanguageVariant[]> => {
+        const { draftVersion, publishedVersion } = categorizeVersions(migrationItem);
+
+        let publishedLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
+        let draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
+        let lastWorkflowStepCodenameInTargetEnvironment: string | undefined;
+
+        const workflow = workflowHelper(config.importContext.environmentData.workflows).getWorkflowByCodename(
+            migrationItem.system.workflow.codename
+        );
+
+        // get initial state of language variant from target env
+        const languageVariantState = config.importContext.getLanguageVariantStateInTargetEnvironment(
+            migrationItem.system.codename,
+            migrationItem.system.language.codename
+        );
+
+        if (languageVariantState.step) {
+            // keep track of last worfklow step
+            lastWorkflowStepCodenameInTargetEnvironment = languageVariantState.step.codename;
+        }
+
+        // first import published version if it exists
+        if (publishedVersion) {
+            publishedLanguageVariant = await importVersionAsync({
+                logSpinner: logSpinner,
+                migrationItem: migrationItem,
+                preparedContentItem: preparedContentItem,
+                migrationItemVersion: publishedVersion,
+                workflowStepCodenameInTargetEnvironment: lastWorkflowStepCodenameInTargetEnvironment
+            });
+
+            // set last published workflow step to publish as language variant has just been published in target environment
+            lastWorkflowStepCodenameInTargetEnvironment = workflow.publishedStep.codename;
+        }
+
+        if (draftVersion) {
+            draftLanguageVariant = await importVersionAsync({
+                logSpinner: logSpinner,
+                migrationItem: migrationItem,
+                preparedContentItem: preparedContentItem,
+                migrationItemVersion: draftVersion,
+                workflowStepCodenameInTargetEnvironment: lastWorkflowStepCodenameInTargetEnvironment
+            });
+        }
+
+        return [
+            ...(publishedLanguageVariant ? [publishedLanguageVariant] : []),
+            ...(draftLanguageVariant ? [draftLanguageVariant] : [])
+        ];
+    };
+
+    const createNewVersionOfLanguageVariantAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationItem: MigrationItem
+    ): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () => {
+                await config.client
+                    .createNewVersionOfLanguageVariant()
+                    .byItemCodename(migrationItem.system.codename)
+                    .byLanguageCodename(migrationItem.system.language.codename)
+                    .toPromise();
+            },
+            action: 'createNewVersion',
+            type: 'languageVariant',
+            logSpinner: logSpinner,
+            itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`
+        });
+    };
+
+    const moveToDraftStepAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationItem: MigrationItem,
+        workflow: Readonly<WorkflowModels.Workflow>
+    ): Promise<void> => {
+        const firstWorkflowStep = workflow.steps?.[0];
+
+        if (firstWorkflowStep) {
+            await runMapiRequestAsync({
+                logger: config.logger,
+                func: async () => {
+                    await config.client
+                        .changeWorkflowStepOfLanguageVariant()
+                        .byItemCodename(migrationItem.system.codename)
+                        .byLanguageCodename(migrationItem.system.language.codename)
+                        .byWorkflowStepCodename(firstWorkflowStep.codename)
+                        .toPromise();
+                },
+                action: 'changeWorkflowStep',
+                type: 'languageVariant',
+                logSpinner: logSpinner,
+                itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename}) -> ${firstWorkflowStep.codename}`
+            });
+        }
+    };
+
+    const prepareLanguageVariantForImportAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly workflowStepCodenameInTargetEnvironment: string;
+        readonly workflow: Readonly<WorkflowModels.Workflow>;
+    }): Promise<void> => {
+        // create new version if language variant is published
+        if (isPublishedWorkflowStep(data.workflowStepCodenameInTargetEnvironment, data.workflow)) {
+            await createNewVersionOfLanguageVariantAsync(data.logSpinner, data.migrationItem);
+        }
+
+        // move to draft step if language variant is archived
+        if (isArchivedWorkflowStep(data.workflowStepCodenameInTargetEnvironment, data.workflow)) {
+            await moveToDraftStepAsync(data.logSpinner, data.migrationItem, data.workflow);
+        }
+    };
+
+    const isPublishedWorkflowStep = (stepCodename: string, workflow: Readonly<WorkflowModels.Workflow>): boolean => {
+        return workflow.publishedStep.codename === stepCodename;
+    };
+
+    const isArchivedWorkflowStep = (stepCodename: string, workflow: Readonly<WorkflowModels.Workflow>): boolean => {
+        return workflow.archivedStep.codename === stepCodename;
+    };
+
+    const getElementContract = (
+        migrationItem: MigrationItem,
+        element: MigrationElement,
+        elementCodename: string
+    ): Readonly<ElementContracts.IContentItemElementContract> => {
+        const importTransformResult = importTransforms[
+            config.importContext.getElement(migrationItem.system.type.codename, elementCodename, element.type).type
+        ]({
+            elementCodename: elementCodename,
+            importContext: config.importContext,
+            migrationItems: config.importContext.categorizedImportData.contentItems,
+            value: element.value
+        });
+
+        return importTransformResult;
+    };
+
+    const importAsync = async (): Promise<readonly Readonly<LanguageVariantModels.ContentItemLanguageVariant>[]> => {
+        config.logger.log({
+            type: 'info',
+            message: `Importing '${chalk.yellow(
+                config.importContext.categorizedImportData.contentItems.length.toString()
+            )}' language variants`
+        });
+
+        return (
+            await processItemsAsync<
+                MigrationItem,
+                readonly Readonly<LanguageVariantModels.ContentItemLanguageVariant>[]
+            >({
+                action: 'Importing language variants',
+                logger: config.logger,
+                parallelLimit: 1,
+                items: config.importContext.categorizedImportData.contentItems,
+                itemInfo: (input) => {
+                    return {
+                        itemType: 'languageVariant',
+                        title: input.system.name,
+                        partA: input.system.language.codename
+                    };
+                },
+                processAsync: async (migrationItem, logSpinner) => {
+                    const contentItem = findRequired(
+                        config.preparedContentItems,
+                        (item) => item.codename === migrationItem.system.codename,
+                        `Missing content item with codename '${chalk.red(
+                            migrationItem.system.codename
+                        )}'. Content item should have been prepepared.`
+                    );
+
+                    return await importLanguageVariantAsync(logSpinner, migrationItem, contentItem);
+                }
+            })
+        ).flatMap((m) => m.map((s) => s));
+    };
+
+    return {
+        importAsync
+    };
+}

package/lib/import/importers/workflow-importer.ts

@@ -0,0 +1,159 @@
+import { ManagementClient, SharedModels, WorkflowModels } from '@kontent-ai/management-sdk';
+import { Logger, runMapiRequestAsync, LogSpinnerData, MigrationItem, workflowHelper } from '../../core/index.js';
+
+export function workflowImporter(config: {
+    logger: Logger;
+    managementClient: Readonly<ManagementClient>;
+    workflows: readonly Readonly<WorkflowModels.Workflow>[];
+}) {
+    const publishLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () =>
+                (
+                    await config.managementClient
+                        .publishLanguageVariant()
+                        .byItemCodename(data.migrationItem.system.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withoutData()
+                        .toPromise()
+                ).data,
+            action: 'publish',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename})`
+        });
+    };
+
+    const unpublishLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        // unpublish the language variant first if published
+        // there is no way to determine if language variant is published via MAPI
+        // so we have to always try unpublishing first and catching possible errors
+        try {
+            await runMapiRequestAsync({
+                logger: config.logger,
+                func: async () =>
+                    (
+                        await config.managementClient
+                            .unpublishLanguageVariant()
+                            .byItemCodename(data.migrationItem.system.codename)
+                            .byLanguageCodename(data.migrationItem.system.language.codename)
+                            .withoutData()
+                            .toPromise()
+                    ).data,
+                action: 'unpublish',
+                type: 'languageVariant',
+                logSpinner: data.logSpinner,
+                itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename})`
+            });
+        } catch (error) {
+            if (error instanceof SharedModels.ContentManagementBaseKontentError) {
+                data.logSpinner({
+                    type: 'unpublish',
+                    message: `Unpublish failed, but this may be expected behavior as we cannot determine if there is a published version already. Error received: ${error.message}`
+                });
+            } else {
+                throw error;
+            }
+        }
+    };
+
+    const archiveLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly workflowCodename: string;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        const workflow = workflowHelper(config.workflows).getWorkflowByCodename(data.workflowCodename);
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () =>
+                (
+                    await config.managementClient
+                        .changeWorkflowOfLanguageVariant()
+                        .byItemCodename(data.migrationItem.system.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withData({
+                            step_identifier: {
+                                codename: workflow.archivedStep.codename
+                            },
+                            workflow_identifier: {
+                                codename: workflow.codename
+                            }
+                        })
+                        .toPromise()
+                ).data,
+            action: 'archive',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> ${workflow.archivedStep.codename}`
+        });
+    };
+
+    const changeWorkflowOfLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly workflowCodename: string;
+        readonly stepCodename: string;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        const { workflow, step } = workflowHelper(config.workflows).getWorkflowAndStepByCodenames({
+            workflowCodename: data.workflowCodename,
+            stepCodename: data.stepCodename
+        });
+
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () =>
+                (
+                    await config.managementClient
+                        .changeWorkflowOfLanguageVariant()
+                        .byItemCodename(data.migrationItem.system.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withData({
+                            step_identifier: {
+                                codename: step.codename
+                            },
+                            workflow_identifier: {
+                                codename: workflow.codename
+                            }
+                        })
+                        .toPromise()
+                ).data,
+            action: 'changeWorkflowStep',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> ${step.codename}`
+        });
+    };
+
+    const setWorkflowOfLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly workflowCodename: string;
+        readonly stepCodename: string;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        if (workflowHelper(config.workflows).isPublishedStepByCodename(data.stepCodename)) {
+            await publishLanguageVariantAsync(data);
+        } else if (workflowHelper(config.workflows).isScheduledStepByCodename(data.stepCodename)) {
+            data.logSpinner({
+                type: 'skip',
+                message: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> Skipping scheduled workflow step assignment`
+            });
+        } else if (workflowHelper(config.workflows).isArchivedStepByCodename(data.stepCodename)) {
+            await unpublishLanguageVariantAsync(data);
+            await archiveLanguageVariantAsync(data);
+        } else {
+            await changeWorkflowOfLanguageVariantAsync(data);
+        }
+    };
+
+    return {
+        setWorkflowOfLanguageVariantAsync,
+        publishLanguageVariantAsync
+    };
+}

package/lib/import/index.ts

@@ -0,0 +1,2 @@
+export * from './import.models.js';
+export * from './import-manager.js';

package/lib/import/utils/import.utils.ts

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+import { MigrationItem } from 'lib/core/index.js';
+
+export function throwErrorForMigrationItem(migrationItem: MigrationItem, message: string): never {
+    throw Error(
+        `Impot failed for item '${chalk.yellow(migrationItem.system.codename)}' in language '${chalk.cyan(
+            migrationItem.system.language
+        )}'. Reason: ${message}`
+    );
+}

package/lib/index.ts

@@ -0,0 +1,9 @@
+// Public API
+export * from './core/index.js';
+export * from './export/index.js';
+export * from './import/index.js';
+export * from './file/index.js';
+export * from './zip/index.js';
+export * from './toolkit/index.js';
+export * from './file/index.js';
+export * from './translation/index.js';

package/lib/metadata.ts

@@ -0,0 +1,6 @@
+
+export const libMetadata = {
+	name: '@kontent-ai/migration-toolkit',
+    timestamp: 'Wed, 10 Jul 2024 10:38:24 GMT',
+    version: '1.0.0'
+};

package/lib/node/cli/actions/export-action.ts

@@ -0,0 +1,45 @@
+import { confirmExportAsync, getDefaultZipFilename, getDefaultLogger } from '../../../core/index.js';
+import { exportAsync, storeAsync } from '../../../toolkit/index.js';
+import { CliArgumentsFetcher } from '../cli.models.js';
+
+export async function exportActionAsync(cliFetcher: CliArgumentsFetcher): Promise<void> {
+    const logger = getDefaultLogger();
+    const language = cliFetcher.getRequiredArgumentValue('language');
+    const environmentId = cliFetcher.getRequiredArgumentValue('sourceEnvironmentId');
+    const apiKey = cliFetcher.getRequiredArgumentValue('sourceApiKey');
+    const items = cliFetcher.getRequiredArgumentValue('items').split(',');
+    const baseUrl = cliFetcher.getOptionalArgumentValue('baseUrl');
+    const force = cliFetcher.getBooleanArgumentValue('force', false);
+    const filename = cliFetcher.getOptionalArgumentValue('filename') ?? getDefaultZipFilename();
+
+    await confirmExportAsync({
+        force: force,
+        apiKey: apiKey,
+        environmentId: environmentId,
+        logger: logger,
+        dataToExport: {
+            itemsCount: items.length
+        }
+    });
+
+    const exportedData = await exportAsync({
+        logger: logger,
+        environmentId: environmentId,
+        apiKey: apiKey,
+        baseUrl: baseUrl,
+        exportItems: items.map((m) => {
+            return {
+                itemCodename: m,
+                languageCodename: language
+            };
+        })
+    });
+
+    await storeAsync({
+        data: exportedData,
+        filename: filename,
+        logger: logger
+    });
+
+    logger.log({ type: 'completed', message: `Export has been successful` });
+}

package/lib/node/cli/actions/import-action.ts

@@ -0,0 +1,34 @@
+import { confirmImportAsync, getDefaultZipFilename, getDefaultLogger } from '../../../core/index.js';
+import { extractAsync, importAsync } from '../../../toolkit/index.js';
+import { CliArgumentsFetcher } from '../cli.models.js';
+
+export async function importActionAsync(argsFetcher: CliArgumentsFetcher): Promise<void> {
+    const log = getDefaultLogger();
+    const environmentId = argsFetcher.getRequiredArgumentValue('targetEnvironmentId');
+    const apiKey = argsFetcher.getRequiredArgumentValue('targetApiKey');
+    const baseUrl = argsFetcher.getOptionalArgumentValue('baseUrl');
+    const force = argsFetcher.getBooleanArgumentValue('force', false);
+    const filename = argsFetcher.getOptionalArgumentValue('filename') ?? getDefaultZipFilename();
+
+    await confirmImportAsync({
+        force: force,
+        apiKey: apiKey,
+        environmentId: environmentId,
+        logger: log
+    });
+
+    const importData = await extractAsync({
+        logger: log,
+        filename: filename
+    });
+
+    await importAsync({
+        logger: log,
+        data: importData,
+        baseUrl: baseUrl,
+        environmentId: environmentId,
+        apiKey: apiKey
+    });
+
+    log.log({ type: 'completed', message: `Import has been successful` });
+}

package/lib/node/cli/actions/migrate-action.ts

@@ -0,0 +1,52 @@
+import { migrateAsync } from '../../../toolkit/index.js';
+import { confirmMigrateAsync, getDefaultLogger } from '../../../core/index.js';
+import { SourceExportItem } from '../../../export/index.js';
+import { CliArgumentsFetcher } from '../cli.models.js';
+
+export async function migrateActionAsync(argsFetcher: CliArgumentsFetcher): Promise<void> {
+    const log = getDefaultLogger();
+    const sourceEnvironmentId = argsFetcher.getRequiredArgumentValue('sourceEnvironmentId');
+    const sourceApiKey = argsFetcher.getRequiredArgumentValue('sourceApiKey');
+    const targetEnvironmentId = argsFetcher.getRequiredArgumentValue('targetEnvironmentId');
+    const targetApiKey = argsFetcher.getRequiredArgumentValue('targetApiKey');
+    const force = argsFetcher.getBooleanArgumentValue('force', false);
+    const items = argsFetcher.getRequiredArgumentValue('items')?.split(',');
+    const language = argsFetcher.getRequiredArgumentValue('language');
+    const migrateItems: readonly SourceExportItem[] = items.map((m) => {
+        return {
+            itemCodename: m,
+            languageCodename: language
+        };
+    });
+
+    await confirmMigrateAsync({
+        force: force,
+        sourceEnvironment: {
+            apiKey: sourceApiKey,
+            environmentId: sourceEnvironmentId
+        },
+        targetEnvironment: {
+            apiKey: targetApiKey,
+            environmentId: targetEnvironmentId
+        },
+        logger: log,
+        dataToMigrate: {
+            itemsCount: migrateItems.length
+        }
+    });
+
+    await migrateAsync({
+        logger: log,
+        sourceEnvironment: {
+            environmentId: sourceEnvironmentId,
+            apiKey: sourceApiKey,
+            items: migrateItems
+        },
+        targetEnvironment: {
+            environmentId: targetEnvironmentId,
+            apiKey: targetApiKey
+        }
+    });
+
+    log.log({ type: 'completed', message: `Migration has been successful` });
+}