@kontent-ai/migration-toolkit 2.2.2 → 2.4.0

package/lib/import/import-manager.ts

@@ -1,12 +1,42 @@
-import { ContentItemModels, LanguageVariantModels, ManagementClient } from '@kontent-ai/management-sdk';
-
-import { defaultExternalIdGenerator, getDefaultLogger, getMigrationManagementClient, Logger } from '../core/index.js';
+import { ManagementClient } from '@kontent-ai/management-sdk';
+import chalk from 'chalk';
+import { defaultExternalIdGenerator, extractErrorData, getDefaultLogger, getMigrationManagementClient, Logger } from '../core/index.js';
 import { importContextFetcherAsync } from './context/import-context-fetcher.js';
-import { ImportConfig, ImportContext, ImportResult } from './import.models.js';
+import { ImportConfig, ImportContext, ImportedItem, ImportedLanguageVariant, ImportResult } from './import.models.js';
 import { assetsImporter } from './importers/assets-importer.js';
 import { contentItemsImporter } from './importers/content-items-importer.js';
 import { languageVariantImporter } from './importers/language-variant-importer.js';
 
+const reportFilename: string = `import-report.json`;
+
+type ReportResult = {
+    readonly errorsCount: number;
+    readonly assets: {
+        readonly count: number;
+        readonly successful: Array<{ readonly codename: string }>;
+        readonly failed: Array<{ readonly codename: string; readonly error: string }>;
+    };
+    readonly languageVariants: {
+        readonly count: number;
+        readonly successful: Array<{
+            readonly codename: string;
+            readonly language: { readonly codename: string };
+            readonly type: { readonly codename: string };
+        }>;
+        readonly failed: Array<{
+            readonly codename: string;
+            readonly language: { readonly codename: string };
+            readonly type: { readonly codename: string };
+            readonly error: string;
+        }>;
+    };
+    readonly contentItems: {
+        readonly count: number;
+        readonly successful: Array<{ readonly codename: string }>;
+        readonly failed: Array<{ readonly codename: string; readonly type: { readonly codename: string }; readonly error: string }>;
+    };
+};
+
 export function importManager(config: ImportConfig) {
     const logger: Logger = config.logger ?? getDefaultLogger();
     const targetEnvironmentClient: Readonly<ManagementClient> = getMigrationManagementClient(config);
@@ -29,7 +59,8 @@ export function importManager(config: ImportConfig) {
             logger: logger
         }).importAsync();
     };
-    const importContentItemsAsync = async (importContext: ImportContext): Promise<readonly Readonly<ContentItemModels.ContentItem>[]> => {
+
+    const importContentItemsAsync = async (importContext: ImportContext): Promise<readonly ImportedItem[]> => {
         if (!importContext.categorizedImportData.contentItems.length) {
             logger.log({
                 type: 'info',
@@ -46,8 +77,8 @@ export function importManager(config: ImportConfig) {
 
     const importLanguageVariantsAsync = async (
         importContext: ImportContext,
-        contentItems: readonly Readonly<ContentItemModels.ContentItem>[]
-    ): Promise<readonly Readonly<LanguageVariantModels.ContentItemLanguageVariant>[]> => {
+        contentItems: readonly ImportedItem[]
+    ): Promise<readonly ImportedLanguageVariant[]> => {
         if (!importContext.categorizedImportData.contentItems.length) {
             logger.log({
                 type: 'info',
@@ -63,6 +94,116 @@ export function importManager(config: ImportConfig) {
         }).importAsync();
     };
 
+    const getReportResult = (importResult: ImportResult): ReportResult => {
+        return {
+            errorsCount:
+                importResult.editedAssets.filter((m) => m.state === 'error').length +
+                importResult.uploadedAssets.filter((m) => m.state === 'error').length +
+                importResult.contentItems.filter((m) => m.state === 'error').length +
+                importResult.languageVariants.filter((m) => m.state === 'error').length,
+            assets: {
+                count: importResult.uploadedAssets.length + importResult.editedAssets.length,
+                successful: [
+                    ...importResult.uploadedAssets.filter((m) => m.state === 'valid').map((m) => m.inputItem.codename),
+                    ...importResult.editedAssets.filter((m) => m.state === 'valid').map((m) => m.inputItem.migrationAsset.codename)
+                ].map((m) => {
+                    return {
+                        codename: m
+                    };
+                }),
+                failed: [
+                    ...importResult.uploadedAssets
+                        .filter((m) => m.state === 'error')
+                        .map((m) => {
+                            return {
+                                codename: m.inputItem.codename,
+                                error: extractErrorData(m.state === 'error').message
+                            };
+                        }),
+                    ...importResult.editedAssets
+                        .filter((m) => m.state === 'error')
+                        .map((m) => {
+                            return {
+                                codename: m.inputItem.migrationAsset.codename,
+                                error: extractErrorData(m.state === 'error').message
+                            };
+                        })
+                ]
+            },
+            contentItems: {
+                count: importResult.contentItems.length,
+                successful: importResult.contentItems
+                    .filter((m) => m.state === 'valid')
+                    .map((m) => {
+                        return {
+                            codename: m.inputItem.system.codename
+                        };
+                    }),
+                failed: importResult.contentItems
+                    .filter((m) => m.state === 'error')
+                    .map((m) => {
+                        return {
+                            codename: m.inputItem.system.codename,
+                            type: m.inputItem.system.type,
+                            error: extractErrorData(m.state === 'error').message
+                        };
+                    })
+            },
+            languageVariants: {
+                count: importResult.languageVariants.length,
+                successful: importResult.languageVariants
+                    .filter((m) => m.state === 'valid')
+                    .map((m) => {
+                        return {
+                            codename: m.inputItem.system.codename,
+                            language: m.inputItem.system.language,
+                            type: m.inputItem.system.type
+                        };
+                    }),
+                failed: importResult.languageVariants
+                    .filter((m) => m.state === 'error')
+                    .map((m) => {
+                        return {
+                            codename: m.inputItem.system.codename,
+                            language: m.inputItem.system.language,
+                            type: m.inputItem.system.type,
+                            error: extractErrorData(m.state === 'error').message
+                        };
+                    })
+            }
+        };
+    };
+
+    const printReportToConsole = (reportResult: ReportResult, logger: Logger): void => {
+        const errors = [
+            ...reportResult.assets.failed.map((m) => [
+                `Object type: ${chalk.yellow('Asset')}`,
+                `Codename: ${chalk.yellow(m.codename)}`,
+                `${chalk.red(m.error)}`
+            ]),
+            ...reportResult.contentItems.failed.map((m) => [
+                `Object type: ${chalk.yellow('Content item')}`,
+                `Codename:${chalk.yellow(m.codename)}`,
+                `Content Type: ${chalk.yellow(m.type.codename)}`,
+                `${chalk.red(m.error)}`
+            ]),
+            ...reportResult.languageVariants.failed.map((m) => [
+                `Object type: ${chalk.yellow('Language variant')}`,
+                `Codename: ${chalk.yellow(m.codename)}`,
+                `Language: ${chalk.yellow(m.language.codename)}`,
+                `Content Type: ${chalk.yellow(m.type.codename)}`,
+                `${chalk.red(m.error)}`
+            ])
+        ];
+
+        errors.forEach((error, index) => {
+            logger.log({ message: `${chalk.red(`\nError #${index + 1}`)}` });
+            error.forEach((m) => {
+                logger.log({ message: m });
+            });
+        });
+    };
+
     return {
         async importAsync(): Promise<ImportResult> {
             const importContext = await (
@@ -83,17 +224,40 @@ export function importManager(config: ImportConfig) {
             // #3 Language variants
             const languageVariants = await importLanguageVariantsAsync(importContext, contentItems);
 
-            logger.log({
-                type: 'completed',
-                message: `Finished import`
+            const reportResult = getReportResult({
+                contentItems,
+                editedAssets,
+                languageVariants,
+                uploadedAssets
             });
 
+            if (reportResult.errorsCount) {
+                printReportToConsole(reportResult, logger);
+                logger.log({
+                    type: 'completed',
+                    message: `Finished import with '${chalk.red(reportResult.errorsCount)}' ${
+                        reportResult.errorsCount === 1 ? 'error' : 'errors'
+                    }`
+                });
+            } else {
+                logger.log({
+                    type: 'completed',
+                    message: `Finished import`
+                });
+            }
+
             return {
                 editedAssets,
                 uploadedAssets,
                 contentItems,
                 languageVariants
             };
+        },
+        getReportFile(importResult: ImportResult): { readonly filename: string; readonly content: string } {
+            return {
+                filename: reportFilename,
+                content: JSON.stringify(getReportResult(importResult))
+            };
         }
     };
 }

package/lib/import/import.models.ts

@@ -14,6 +14,7 @@ import {
     ExternalIdGenerator,
     FlattenedContentType,
     FlattenedContentTypeElement,
+    ItemProcessingResult,
     ItemStateInTargetEnvironmentByCodename,
     LanguageVariantStateInTargetEnvironmentByCodename,
     Logger,
@@ -75,12 +76,27 @@ export type ImportTransformFunc = (data: {
 export interface ImportConfig extends ManagementClientConfig {
     readonly data: MigrationData;
     readonly externalIdGenerator?: ExternalIdGenerator;
+    readonly createReportFile?: boolean;
     readonly logger?: Logger;
 }
 
+export interface AssetToEdit {
+    readonly migrationAsset: MigrationAsset;
+    readonly targetAsset: Readonly<AssetModels.Asset>;
+    readonly replaceBinaryFile: boolean;
+}
+
+export type ImportedItem = ItemProcessingResult<MigrationItem, Readonly<ContentItemModels.ContentItem>>;
+export type ImportedLanguageVariant = ItemProcessingResult<
+    MigrationItem,
+    readonly Readonly<LanguageVariantModels.ContentItemLanguageVariant>[]
+>;
+export type EditedAsset = ItemProcessingResult<AssetToEdit, Readonly<AssetModels.Asset>>;
+export type ImportedAsset = ItemProcessingResult<MigrationAsset, Readonly<AssetModels.Asset>>;
+
 export interface ImportResult {
-    readonly uploadedAssets: readonly Readonly<AssetModels.Asset>[];
-    readonly editedAssets: readonly Readonly<AssetModels.Asset>[];
-    readonly contentItems: readonly Readonly<ContentItemModels.ContentItem>[];
-    readonly languageVariants: readonly Readonly<LanguageVariantModels.ContentItemLanguageVariant>[];
+    readonly uploadedAssets: readonly ImportedAsset[];
+    readonly editedAssets: readonly EditedAsset[];
+    readonly contentItems: readonly ImportedItem[];
+    readonly languageVariants: readonly ImportedLanguageVariant[];
 }

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

@@ -13,13 +13,7 @@ import {
     runMapiRequestAsync
 } from '../../core/index.js';
 import { shouldReplaceBinaryFile, shouldUpdateAsset } from '../comparers/asset-comparer.js';
-import { ImportContext, ImportResult } from '../import.models.js';
-
-interface AssetToEdit {
-    migrationAsset: MigrationAsset;
-    targetAsset: Readonly<AssetModels.Asset>;
-    replaceBinaryFile: boolean;
-}
+import { AssetToEdit, EditedAsset, ImportContext, ImportedAsset, ImportResult } from '../import.models.js';
 
 export function assetsImporter(data: {
     readonly logger: Logger;
@@ -70,7 +64,7 @@ export function assetsImporter(data: {
             .filter(isNotUndefined);
     };
 
-    const editAssets = async (assetsToEdit: readonly AssetToEdit[]): Promise<readonly Readonly<AssetModels.Asset>[]> => {
+    const editAssets = async (assetsToEdit: readonly AssetToEdit[]): Promise<readonly EditedAsset[]> => {
         data.logger.log({
             type: 'upsert',
             message: `Upserting '${chalk.yellow(assetsToEdit.length.toString())}' assets`
@@ -189,7 +183,7 @@ export function assetsImporter(data: {
         });
     };
 
-    const uploadAssetsAsync = async (assetsToUpload: readonly MigrationAsset[]): Promise<readonly Readonly<AssetModels.Asset>[]> => {
+    const uploadAssetsAsync = async (assetsToUpload: readonly MigrationAsset[]): Promise<readonly ImportedAsset[]> => {
         data.logger.log({
             type: 'upload',
             message: `Uploading '${chalk.yellow(assetsToUpload.length.toString())}' assets`

package/lib/import/importers/content-items-importer.ts

@@ -1,43 +1,28 @@
 import { ContentItemModels, ManagementClient } from '@kontent-ai/management-sdk';
-import {
-    Logger,
-    processItemsAsync,
-    runMapiRequestAsync,
-    MigrationItem,
-    LogSpinnerData,
-    findRequired
-} from '../../core/index.js';
 import chalk from 'chalk';
-import { ImportContext } from '../import.models.js';
+import { LogSpinnerData, Logger, MigrationItem, findRequired, processItemsAsync, runMapiRequestAsync } from '../../core/index.js';
+import { ImportContext, ImportedItem } from '../import.models.js';
 
 export function contentItemsImporter(data: {
     readonly logger: Logger;
     readonly client: Readonly<ManagementClient>;
     readonly importContext: ImportContext;
 }) {
-    const shouldUpdateContentItem = (
-        migrationContentItem: MigrationItem,
-        contentItem: Readonly<ContentItemModels.ContentItem>
-    ): boolean => {
+    const shouldUpdateContentItem = (migrationItem: MigrationItem, contentItem: Readonly<ContentItemModels.ContentItem>): boolean => {
         const collection = findRequired(
             data.importContext.environmentData.collections,
-            (collection) => collection.codename === migrationContentItem.system.collection.codename,
-            `Invalid collection '${migrationContentItem.system.collection.codename}'`
+            (collection) => collection.id === contentItem.collection.id,
+            `Invalid collection with id '${contentItem.collection.id}' for content item '${contentItem.codename}'`
         );
 
-        return (
-            migrationContentItem.system.name !== contentItem.name ||
-            migrationContentItem.system.collection.codename !== collection.codename
-        );
+        return migrationItem.system.name !== contentItem.name || migrationItem.system.collection.codename !== collection.codename;
     };
 
     const prepareContentItemAsync = async (
         logSpinner: LogSpinnerData,
-        migrationContentItem: MigrationItem
+        migrationItem: MigrationItem
     ): Promise<{ contentItem: Readonly<ContentItemModels.ContentItem>; status: 'created' | 'itemAlreadyExists' }> => {
-        const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(
-            migrationContentItem.system.codename
-        );
+        const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(migrationItem.system.codename);
 
         if (itemStateInTargetEnv.state === 'exists' && itemStateInTargetEnv.item) {
             return {
@@ -53,14 +38,14 @@ export function contentItemsImporter(data: {
                     await data.client
                         .addContentItem()
                         .withData({
-                            name: migrationContentItem.system.name,
+                            name: migrationItem.system.name,
                             type: {
-                                codename: migrationContentItem.system.type.codename
+                                codename: migrationItem.system.type.codename
                             },
                             external_id: itemStateInTargetEnv.externalIdToUse,
-                            codename: migrationContentItem.system.codename,
+                            codename: migrationItem.system.codename,
                             collection: {
-                                codename: migrationContentItem.system.collection.codename
+                                codename: migrationItem.system.collection.codename
                             }
                         })
                         .toPromise()
@@ -68,7 +53,7 @@ export function contentItemsImporter(data: {
             action: 'create',
             type: 'contentItem',
             logSpinner: logSpinner,
-            itemName: `${migrationContentItem.system.codename} (${migrationContentItem.system.language.codename})`
+            itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`
         });
 
         return {
@@ -111,8 +96,19 @@ export function contentItemsImporter(data: {
         return preparedContentItemResult.contentItem;
     };
 
-    const importAsync = async (): Promise<readonly Readonly<ContentItemModels.ContentItem>[]> => {
-        const contentItemsToImport = data.importContext.categorizedImportData.contentItems;
+    const importAsync = async (): Promise<readonly ImportedItem[]> => {
+        // Only import unique content items based on their codename. The input may contain items in various language variants which share
+        // the same underlying content item.
+        const contentItemsToImport = data.importContext.categorizedImportData.contentItems.reduce<Readonly<MigrationItem[]>>(
+            (filteredItems, item) => {
+                if (filteredItems.some((m) => m.system.codename === item.system.codename)) {
+                    return filteredItems;
+                }
+
+                return [...filteredItems, item];
+            },
+            []
+        );
 
         data.logger.log({
             type: 'info',
@@ -127,7 +123,7 @@ export function contentItemsImporter(data: {
             itemInfo: (item) => {
                 return {
                     itemType: 'contentItem',
-                    title: `${item.system.codename} -> ${item.system.language.codename}`
+                    title: `${item.system.codename} -> ${item.system.type.codename}`
                 };
             },
             processAsync: async (item, logSpinner) => {

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

@@ -1,4 +1,4 @@
-import { ContentItemModels, ElementContracts, LanguageVariantModels, ManagementClient, WorkflowModels } from '@kontent-ai/management-sdk';
+import { ElementContracts, LanguageVariantModels, ManagementClient, WorkflowModels } from '@kontent-ai/management-sdk';
 import chalk from 'chalk';
 import { match } from 'ts-pattern';
 import {
@@ -16,13 +16,13 @@ import {
     workflowHelper
 } from '../../core/index.js';
 import { importTransforms } from '../../translation/index.js';
-import { ImportContext } from '../import.models.js';
+import { ImportContext, ImportedItem, ImportedLanguageVariant } from '../import.models.js';
 import { throwErrorForMigrationItem } from '../utils/import.utils.js';
 import { workflowImporter as workflowImporterInit } from './workflow-importer.js';
 
 export function languageVariantImporter(config: {
     readonly logger: Logger;
-    readonly preparedContentItems: readonly ContentItemModels.ContentItem[];
+    readonly preparedContentItems: readonly ImportedItem[];
     readonly importContext: ImportContext;
     readonly client: Readonly<ManagementClient>;
 }) {
@@ -37,7 +37,7 @@ export function languageVariantImporter(config: {
         readonly logSpinner: LogSpinnerData;
         readonly migrationItem: MigrationItem;
         readonly migrationItemVersion: MigrationItemVersion;
-        readonly preparedContentItem: Readonly<ContentItemModels.ContentItem>;
+        readonly preparedContentItem: ImportedItem;
     }): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant>> => {
         return await runMapiRequestAsync({
             logger: config.logger,
@@ -45,7 +45,7 @@ export function languageVariantImporter(config: {
                 return (
                     await config.client
                         .upsertLanguageVariant()
-                        .byItemCodename(data.preparedContentItem.codename)
+                        .byItemCodename(data.preparedContentItem.inputItem.system.codename)
                         .byLanguageCodename(data.migrationItem.system.language.codename)
                         .withData(() => {
                             return {
@@ -110,7 +110,7 @@ export function languageVariantImporter(config: {
         readonly logSpinner: LogSpinnerData;
         readonly migrationItem: MigrationItem;
         readonly migrationItemVersion: MigrationItemVersion;
-        readonly preparedContentItem: Readonly<ContentItemModels.ContentItem>;
+        readonly preparedContentItem: ImportedItem;
         readonly createNewVersion?: boolean;
     }): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant>> => {
         // validate workflow
@@ -158,7 +158,7 @@ export function languageVariantImporter(config: {
     const importLanguageVariantAsync = async (
         logSpinner: LogSpinnerData,
         migrationItem: MigrationItem,
-        preparedContentItem: Readonly<ContentItemModels.ContentItem>
+        preparedContentItem: ImportedItem
     ): Promise<readonly LanguageVariantModels.ContentItemLanguageVariant[]> => {
         const { draftVersion, publishedVersion } = categorizeVersions(migrationItem);
 
@@ -297,7 +297,7 @@ export function languageVariantImporter(config: {
         return importTransformResult;
     };
 
-    const importAsync = async (): Promise<readonly Readonly<LanguageVariantModels.ContentItemLanguageVariant>[]> => {
+    const importAsync = async (): Promise<readonly ImportedLanguageVariant[]> => {
         config.logger.log({
             type: 'info',
             message: `Importing '${chalk.yellow(
@@ -305,32 +305,30 @@ export function languageVariantImporter(config: {
             )}' 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 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.inputItem.system.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);
+            }
+        });
     };
 
     return {

package/lib/metadata.ts

@@ -1,6 +1,6 @@
 
 export const libMetadata = {
 	name: '@kontent-ai/migration-toolkit',
-    timestamp: 'Thu, 07 Nov 2024 07:54:04 GMT',
-    version: '2.2.2'
+    timestamp: 'Thu, 02 Jan 2025 12:45:27 GMT',
+    version: '2.4.0'
 };

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

@@ -7,6 +7,7 @@ export async function importActionAsync(argsFetcher: CliArgumentsFetcher): Promi
     const environmentId = argsFetcher.getRequiredArgumentValue('targetEnvironmentId');
     const apiKey = argsFetcher.getRequiredArgumentValue('targetApiKey');
     const baseUrl = argsFetcher.getOptionalArgumentValue('baseUrl');
+    const createReportFile = argsFetcher.getBooleanArgumentValue('createReportFile', false);
     const force = argsFetcher.getBooleanArgumentValue('force', false);
     const filename = argsFetcher.getOptionalArgumentValue('filename') ?? defaultZipFilename;
 
@@ -27,7 +28,8 @@ export async function importActionAsync(argsFetcher: CliArgumentsFetcher): Promi
         data: importData,
         baseUrl: baseUrl,
         environmentId: environmentId,
-        apiKey: apiKey
+        apiKey: apiKey,
+        createReportFile: createReportFile
     });
 
     log.log({ type: 'completed', message: `Import has been successful` });

package/lib/toolkit/file.ts

@@ -1,4 +1,4 @@
-import { Buffer } from 'buffer';
+import { Buffer as BufferProxy } from 'buffer';
 import { defaultZipFilename, executeWithTrackingAsync, getDefaultLogger, Logger, MigrationData } from '../core/index.js';
 import { fileManager } from '../file/index.js';
 import { libMetadata } from '../metadata.js';
@@ -33,7 +33,7 @@ export async function storeAsync(config: StoreConfig): Promise<void> {
         func: async () => {
             const zipData = await zipManager(logger).createZipAsync(config.data);
 
-            if (zipData instanceof Buffer) {
+            if (zipData instanceof BufferProxy) {
                 await fileManager(logger).writeFileAsync(filename, zipData);
             } else {
                 throw Error(`Cannot store '${filename}' on File system because the provided zip is not a Buffer`);

package/lib/toolkit/import.ts

@@ -1,5 +1,7 @@
+import chalk from 'chalk';
+import { writeFile } from 'fs/promises';
 import { executeWithTrackingAsync } from '../core/index.js';
-import { ImportConfig, ImportResult, importManager } from '../import/index.js';
+import { ImportConfig, ImportResult, importManager as _importManager } from '../import/index.js';
 import { libMetadata } from '../metadata.js';
 
 export async function importAsync(config: ImportConfig): Promise<ImportResult> {
@@ -15,7 +17,19 @@ export async function importAsync(config: ImportConfig): Promise<ImportResult> {
             details: {}
         },
         func: async () => {
-            return await importManager(config).importAsync();
+            const importManager = _importManager(config);
+            const importResult = await importManager.importAsync();
+
+            if (config.createReportFile) {
+                const reportFile = importManager.getReportFile(importResult);
+                await writeFile(reportFile.filename, reportFile.content);
+                config.logger?.log({
+                    type: 'writeFs',
+                    message: `Report '${chalk.yellow(reportFile.filename)}' was created`
+                });
+            }
+
+            return importResult;
         },
         logger: config.logger
     });

package/lib/translation/extraction/items-extraction.processor.ts

@@ -12,7 +12,7 @@ import { GetFlattenedElementByCodenames } from '../../import/index.js';
 import { richTextProcessor } from '../index.js';
 
 export interface ExtractItemById {
-    readonly elements: Readonly<ElementModels.ContentItemElement>[];
+    readonly elements: readonly Readonly<ElementModels.ContentItemElement>[];
     readonly contentTypeId: string;
 }
 
@@ -95,7 +95,7 @@ export function itemsExtractionProcessor() {
             { itemIds: new Set(), assetIds: new Set() }
         );
 
-        return <ReferencedDataInLanguageVariants>{
+        return {
             itemIds: extractedIds.itemIds,
             assetIds: extractedIds.assetIds
         };
@@ -175,7 +175,7 @@ export function itemsExtractionProcessor() {
             }
         );
 
-        return <ReferencedDataInMigrationItems>{
+        return {
             itemCodenames: extractedCodenames.itemCodenames,
             assetCodenames: extractedCodenames.assetCodenames
         };

package/lib/translation/helpers/rich-text.processor.ts

@@ -1,7 +1,7 @@
 import { AssetStateInTargetEnvironmentByCodename, ItemStateInTargetEnvironmentByCodename } from 'lib/core/index.js';
 
-type CodenameReplaceFunc<T> = (codename: string) => T;
-type IdReplaceFunc = (id: string) => { codename: string };
+export type CodenameReplaceFunc<T> = (codename: string) => T;
+export type IdReplaceFunc = (id: string) => { codename: string };
 
 interface ProcessCodenamesResult {
     readonly codenames: ReadonlySet<string>;
@@ -35,7 +35,7 @@ const rteRegexes = {
         objectTagRegex: new RegExp(`<object(.+?)</object>`, 'g'),
         imgTagRegex: new RegExp(`<img(.+?)</img>`, 'g'),
         figureTagRegex: new RegExp(`<figure(.+?)</figure>`, 'g'),
-        linkTagRegex: new RegExp(`<a(.+?)</a>`, 'g')
+        linkTagRegex: new RegExp(`<a([\\s\\S]*)</a>`, 'gm')
     },
     ids: {
         dataItemIdAttrRegex: new RegExp(`${attributes.ids.itemIdAttributeName}=\\"(.+?)\\"`),
@@ -324,7 +324,7 @@ export function richTextProcessor() {
             html: richTextHtml
         };
     };
-    
+
     const processLinkAssetCodenames = (
         richTextHtml: string,
         replaceFunc?: CodenameReplaceFunc<AssetStateInTargetEnvironmentByCodename>