@kontent-ai/migration-toolkit 2.2.2 → 2.3.0

package/lib/export/export-manager.ts

@@ -45,8 +45,8 @@ export function exportManager(config: ExportConfig) {
                     codename: exportItem.workflow.codename
                 }
             },
-            versions: exportItem.versions.map((version) => {
-                return <MigrationItemVersion>{
+            versions: exportItem.versions.map<MigrationItemVersion>((version) => {
+                return {
                     elements: getMigrationElements(context, exportItem.contentType, version.languageVariant.elements),
                     schedule: {
                         publish_time: version.languageVariant.schedule.publishTime ?? undefined,
@@ -124,10 +124,10 @@ export function exportManager(config: ExportConfig) {
     };
 
     const getMigrationElementToStore = (data: {
-        context: ExportContext;
-        contentType: FlattenedContentType;
-        typeElement: FlattenedContentTypeElement;
-        exportElement: ElementModels.ContentItemElement;
+        readonly context: ExportContext;
+        readonly contentType: FlattenedContentType;
+        readonly typeElement: FlattenedContentTypeElement;
+        readonly exportElement: ElementModels.ContentItemElement;
     }): MigrationElementTransformData => {
         try {
             return exportTransforms[data.typeElement.type]({
@@ -175,60 +175,62 @@ export function exportManager(config: ExportConfig) {
             message: `Preparing to download '${chalk.yellow(assets.length.toString())}' assets`
         });
 
-        return await processItemsAsync<Readonly<AssetModels.Asset>, MigrationAsset>({
-            action: 'Downloading assets',
-            logger: logger,
-            parallelLimit: 5,
-            itemInfo: (input) => {
-                return {
-                    title: input.codename,
-                    itemType: 'asset'
-                };
-            },
-            items: assets,
-            processAsync: async (asset, logSpinner) => {
-                const assetCollection: Readonly<CollectionModels.Collection> | undefined = context.environmentData.collections.find(
-                    (m) => m.id === asset.collection?.reference?.id
-                );
-                const assetFolder: Readonly<AssetFolderModels.AssetFolder> | undefined = context.environmentData.assetFolders.find(
-                    (m) => m.id === asset.folder?.id
-                );
+        return (
+            await processItemsAsync<Readonly<AssetModels.Asset>, MigrationAsset>({
+                action: 'Downloading assets',
+                logger: logger,
+                parallelLimit: 5,
+                itemInfo: (input) => {
+                    return {
+                        title: input.codename,
+                        itemType: 'asset'
+                    };
+                },
+                items: assets,
+                processAsync: async (asset, logSpinner) => {
+                    const assetCollection: Readonly<CollectionModels.Collection> | undefined = context.environmentData.collections.find(
+                        (m) => m.id === asset.collection?.reference?.id
+                    );
+                    const assetFolder: Readonly<AssetFolderModels.AssetFolder> | undefined = context.environmentData.assetFolders.find(
+                        (m) => m.id === asset.folder?.id
+                    );
 
-                logSpinner({
-                    type: 'download',
-                    message: `${asset.url}`
-                });
+                    logSpinner({
+                        type: 'download',
+                        message: `${asset.url}`
+                    });
 
-                const binaryData = await getBinaryDataFromUrlAsync(asset.url);
+                    const migrationAsset: MigrationAsset = {
+                        filename: asset.fileName,
+                        title: asset.title ?? '',
+                        codename: asset.codename,
+                        binary_data: (await getBinaryDataFromUrlAsync(asset.url)).data,
+                        collection: assetCollection ? { codename: assetCollection.codename } : undefined,
+                        folder: assetFolder ? { codename: assetFolder.codename } : undefined,
+                        descriptions: asset.descriptions.map((description) => {
+                            const language = findRequired(
+                                context.environmentData.languages,
+                                (language) => language.id === description.language.id,
+                                `Could not find language with id '${chalk.red(description.language.id)}' requested by asset '${chalk.red(
+                                    asset.codename
+                                )}'`
+                            );
 
-                const migrationAsset: MigrationAsset = {
-                    filename: asset.fileName,
-                    title: asset.title ?? '',
-                    codename: asset.codename,
-                    binary_data: binaryData.data,
-                    collection: assetCollection ? { codename: assetCollection.codename } : undefined,
-                    folder: assetFolder ? { codename: assetFolder.codename } : undefined,
-                    descriptions: asset.descriptions.map((description) => {
-                        const language = findRequired(
-                            context.environmentData.languages,
-                            (language) => language.id === description.language.id,
-                            `Could not find language with id '${chalk.red(description.language.id)}' requested by asset '${chalk.red(
-                                asset.codename
-                            )}'`
-                        );
+                            return {
+                                description: description.description ?? undefined,
+                                language: {
+                                    codename: language.codename
+                                }
+                            };
+                        })
+                    };
 
-                        return {
-                            description: description.description ?? undefined,
-                            language: {
-                                codename: language.codename
-                            }
-                        };
-                    })
-                };
-
-                return migrationAsset;
-            }
-        });
+                    return migrationAsset;
+                }
+            })
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     return {

package/lib/file/file-manager.ts

@@ -1,13 +1,14 @@
+import { Buffer as BufferProxy } from 'buffer';
 import chalk from 'chalk';
-import { Logger } from '../core/index.js';
 import { promises } from 'fs';
+import { Logger } from '../core/index.js';
 
 export function fileManager(logger: Logger) {
     const getFilePath = (filename: string): string => {
         return `./${filename}`;
     };
 
-    const loadFileAsync = async (filename: string): Promise<Buffer> => {
+    const loadFileAsync = async (filename: string): Promise<BufferProxy> => {
         const filePath = getFilePath(filename);
 
         logger.log({
@@ -20,7 +21,7 @@ export function fileManager(logger: Logger) {
         return file;
     };
 
-    const writeFileAsync = async (fileNameWithoutExtension: string, content: string | Buffer): Promise<void> => {
+    const writeFileAsync = async (fileNameWithoutExtension: string, content: string | BufferProxy): Promise<void> => {
         const filePath = getFilePath(fileNameWithoutExtension);
 
         logger.log({

package/lib/import/context/import-context-fetcher.ts

@@ -1,4 +1,6 @@
 import { AssetModels, ContentItemModels, LanguageVariantModels } from '@kontent-ai/management-sdk';
+import chalk from 'chalk';
+import { match } from 'ts-pattern';
 import {
     AssetStateInTargetEnvironmentByCodename,
     ItemStateInTargetEnvironmentByCodename,
@@ -12,16 +14,13 @@ import {
     WorkflowStep,
     findRequired,
     is404Error,
-    isNotUndefined,
     managementClientUtils,
     processItemsAsync,
     runMapiRequestAsync,
     workflowHelper as workflowHelperInit
 } from '../../core/index.js';
-import { GetFlattenedElementByCodenames, ImportContext, ImportContextConfig, ImportContextEnvironmentData } from '../import.models.js';
 import { ExtractItemByCodename, itemsExtractionProcessor } from '../../translation/index.js';
-import chalk from 'chalk';
-import { match } from 'ts-pattern';
+import { GetFlattenedElementByCodenames, ImportContext, ImportContextConfig, ImportContextEnvironmentData } from '../import.models.js';
 
 interface LanguageVariantWrapper {
     readonly draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
@@ -150,7 +149,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
         migrationItems: readonly MigrationItem[]
     ): Promise<readonly LanguageVariantWrapper[]> => {
         return (
-            await processItemsAsync<MigrationItem, LanguageVariantWrapper | undefined>({
+            await processItemsAsync<MigrationItem, LanguageVariantWrapper>({
                 action: 'Fetching language variants',
                 logger: config.logger,
                 parallelLimit: 1,
@@ -166,7 +165,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
 
                     if (!latestLanguageVariant) {
                         // there is neither published or draft version as latest version does not exist at all
-                        return undefined;
+                        return '404';
                     }
 
                     if (workflowHelper.isPublishedStepById(latestLanguageVariant.workflow.stepIdentifier.id ?? '')) {
@@ -186,14 +185,16 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                     };
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getContentItemsByCodenamesAsync = async (
         itemCodenames: ReadonlySet<string>
     ): Promise<readonly ContentItemModels.ContentItem[]> => {
         return (
-            await processItemsAsync<string, Readonly<ContentItemModels.ContentItem> | undefined>({
+            await processItemsAsync<string, Readonly<ContentItemModels.ContentItem>>({
                 action: 'Fetching content items',
                 logger: config.logger,
                 parallelLimit: 1,
@@ -219,16 +220,18 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                             throw error;
                         }
 
-                        return undefined;
+                        return '404';
                     }
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getAssetsByCodenamesAsync = async (assetCodenames: ReadonlySet<string>): Promise<readonly AssetModels.Asset[]> => {
         return (
-            await processItemsAsync<string, Readonly<AssetModels.Asset> | undefined>({
+            await processItemsAsync<string, Readonly<AssetModels.Asset>>({
                 action: 'Fetching assets',
                 logger: config.logger,
                 parallelLimit: 1,
@@ -254,11 +257,13 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                             throw error;
                         }
 
-                        return undefined;
+                        return '404';
                     }
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getVariantState = (languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant>): LanguageVariantStateData => {

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,14 +1,7 @@
 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;
@@ -26,8 +19,7 @@ export function contentItemsImporter(data: {
         );
 
         return (
-            migrationContentItem.system.name !== contentItem.name ||
-            migrationContentItem.system.collection.codename !== collection.codename
+            migrationContentItem.system.name !== contentItem.name || migrationContentItem.system.collection.codename !== collection.codename
         );
     };
 
@@ -35,9 +27,7 @@ export function contentItemsImporter(data: {
         logSpinner: LogSpinnerData,
         migrationContentItem: MigrationItem
     ): Promise<{ contentItem: Readonly<ContentItemModels.ContentItem>; status: 'created' | 'itemAlreadyExists' }> => {
-        const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(
-            migrationContentItem.system.codename
-        );
+        const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(migrationContentItem.system.codename);
 
         if (itemStateInTargetEnv.state === 'exists' && itemStateInTargetEnv.item) {
             return {
@@ -111,8 +101,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 +128,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) => {