@kontent-ai/migration-toolkit 2.9.1 → 3.0.0-0

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

@@ -1,139 +1,143 @@
-import type { ContentItemModels, ManagementClient } from '@kontent-ai/management-sdk';
-import chalk from 'chalk';
-import type { LogSpinnerData, Logger, MigrationItem } from '../../core/index.js';
-import { findRequired, processItemsAsync, runMapiRequestAsync } from '../../core/index.js';
-import type { ImportContext, ImportedItem } from '../import.models.js';
+import type { ContentItemModels, ManagementClient } from "@kontent-ai/management-sdk";
+import chalk from "chalk";
+import type { Logger, LogSpinnerData } from "../../core/models/log.models.js";
+import type { MigrationItem } from "../../core/models/migration.models.js";
+import { findRequired } from "../../core/utils/array.utils.js";
+import { processItemsAsync } from "../../core/utils/processing-utils.js";
+import { runMapiRequestAsync } from "../../core/utils/run.utils.js";
+import type { ImportContext, ImportedItem } from "../import.models.js";
 
 export function contentItemsImporter(data: {
-    readonly logger: Logger;
-    readonly client: Readonly<ManagementClient>;
-    readonly importContext: ImportContext;
+	readonly logger: Logger;
+	readonly client: Readonly<ManagementClient>;
+	readonly importContext: ImportContext;
 }) {
-    const shouldUpdateContentItem = (migrationItem: MigrationItem, contentItem: Readonly<ContentItemModels.ContentItem>): boolean => {
-        const collection = findRequired(
-            data.importContext.environmentData.collections,
-            (collection) => collection.id === contentItem.collection.id,
-            `Invalid collection with id '${contentItem.collection.id}' for content item '${contentItem.codename}'`
-        );
+	const shouldUpdateContentItem = (migrationItem: MigrationItem, contentItem: Readonly<ContentItemModels.ContentItem>): boolean => {
+		const collection = findRequired(
+			data.importContext.environmentData.collections,
+			(collection) => collection.id === contentItem.collection.id,
+			`Invalid collection with id '${contentItem.collection.id}' for content item '${contentItem.codename}'`,
+		);
 
-        return migrationItem.system.name !== contentItem.name || migrationItem.system.collection.codename !== collection.codename;
-    };
+		return migrationItem.system.name !== contentItem.name || migrationItem.system.collection.codename !== collection.codename;
+	};
 
-    const prepareContentItemAsync = async (
-        logSpinner: LogSpinnerData,
-        migrationItem: MigrationItem
-    ): Promise<{ contentItem: Readonly<ContentItemModels.ContentItem>; status: 'created' | 'itemAlreadyExists' }> => {
-        const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(migrationItem.system.codename);
+	const prepareContentItemAsync = async (
+		logSpinner: LogSpinnerData,
+		migrationItem: MigrationItem,
+	): Promise<{ contentItem: Readonly<ContentItemModels.ContentItem>; status: "created" | "itemAlreadyExists" }> => {
+		const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(migrationItem.system.codename);
 
-        if (itemStateInTargetEnv.state === 'exists' && itemStateInTargetEnv.item) {
-            return {
-                contentItem: itemStateInTargetEnv.item,
-                status: 'itemAlreadyExists'
-            };
-        }
+		if (itemStateInTargetEnv.state === "exists" && itemStateInTargetEnv.item) {
+			return {
+				contentItem: itemStateInTargetEnv.item,
+				status: "itemAlreadyExists",
+			};
+		}
 
-        const createdContentItem = await runMapiRequestAsync({
-            logger: data.logger,
-            func: async () =>
-                (
-                    await data.client
-                        .addContentItem()
-                        .withData({
-                            name: migrationItem.system.name,
-                            type: {
-                                codename: migrationItem.system.type.codename
-                            },
-                            external_id: itemStateInTargetEnv.externalIdToUse,
-                            codename: migrationItem.system.codename,
-                            collection: {
-                                codename: migrationItem.system.collection.codename
-                            }
-                        })
-                        .toPromise()
-                ).data,
-            action: 'create',
-            type: 'contentItem',
-            logSpinner: logSpinner,
-            itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`
-        });
+		const createdContentItem = await runMapiRequestAsync({
+			logger: data.logger,
+			func: async () =>
+				(
+					await data.client
+						.addContentItem()
+						.withData({
+							name: migrationItem.system.name,
+							type: {
+								codename: migrationItem.system.type.codename,
+							},
+							external_id: itemStateInTargetEnv.externalIdToUse,
+							codename: migrationItem.system.codename,
+							collection: {
+								codename: migrationItem.system.collection.codename,
+							},
+						})
+						.toPromise()
+				).data,
+			action: "create",
+			type: "contentItem",
+			logSpinner: logSpinner,
+			itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`,
+		});
 
-        return {
-            contentItem: createdContentItem,
-            status: 'created'
-        };
-    };
+		return {
+			contentItem: createdContentItem,
+			status: "created",
+		};
+	};
 
-    const importContentItemAsync = async (
-        logSpinner: LogSpinnerData,
-        migrationItem: MigrationItem
-    ): Promise<Readonly<ContentItemModels.ContentItem>> => {
-        const preparedContentItemResult = await prepareContentItemAsync(logSpinner, migrationItem);
+	const importContentItemAsync = async (
+		logSpinner: LogSpinnerData,
+		migrationItem: MigrationItem,
+	): Promise<Readonly<ContentItemModels.ContentItem>> => {
+		const preparedContentItemResult = await prepareContentItemAsync(logSpinner, migrationItem);
 
-        // check if name should be updated, no other changes are supported
-        if (preparedContentItemResult.status === 'itemAlreadyExists') {
-            if (shouldUpdateContentItem(migrationItem, preparedContentItemResult.contentItem)) {
-                await runMapiRequestAsync({
-                    logger: data.logger,
-                    func: async () => {
-                        await data.client
-                            .upsertContentItem()
-                            .byItemCodename(migrationItem.system.codename)
-                            .withData({
-                                name: migrationItem.system.name,
-                                collection: {
-                                    codename: migrationItem.system.collection.codename
-                                }
-                            })
-                            .toPromise();
-                    },
-                    action: 'upsert',
-                    type: 'contentItem',
-                    logSpinner: logSpinner,
-                    itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`
-                });
-            }
-        }
+		// check if name should be updated, no other changes are supported
+		if (preparedContentItemResult.status === "itemAlreadyExists") {
+			if (shouldUpdateContentItem(migrationItem, preparedContentItemResult.contentItem)) {
+				await runMapiRequestAsync({
+					logger: data.logger,
+					func: async () => {
+						await data.client
+							.upsertContentItem()
+							.byItemCodename(migrationItem.system.codename)
+							.withData({
+								name: migrationItem.system.name,
+								collection: {
+									codename: migrationItem.system.collection.codename,
+								},
+							})
+							.toPromise();
+					},
+					action: "upsert",
+					type: "contentItem",
+					logSpinner: logSpinner,
+					itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`,
+				});
+			}
+		}
 
-        return preparedContentItemResult.contentItem;
-    };
+		return preparedContentItemResult.contentItem;
+	};
 
-    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;
-                }
+	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<MigrationItem[]>(
+			(filteredItems, item) => {
+				if (filteredItems.some((m) => m.system.codename === item.system.codename)) {
+					return filteredItems;
+				}
 
-                return [...filteredItems, item];
-            },
-            []
-        );
+				filteredItems.push(item);
+				return filteredItems;
+			},
+			[],
+		);
 
-        data.logger.log({
-            type: 'info',
-            message: `Importing '${chalk.yellow(contentItemsToImport.length.toString())}' content items`
-        });
+		data.logger.log({
+			type: "info",
+			message: `Importing '${chalk.yellow(contentItemsToImport.length.toString())}' content items`,
+		});
 
-        return await processItemsAsync<MigrationItem, Readonly<ContentItemModels.ContentItem>>({
-            action: 'Importing content items',
-            logger: data.logger,
-            parallelLimit: 1,
-            items: contentItemsToImport,
-            itemInfo: (item) => {
-                return {
-                    itemType: 'contentItem',
-                    title: `${item.system.codename} -> ${item.system.type.codename}`
-                };
-            },
-            processAsync: async (item, logSpinner) => {
-                return await importContentItemAsync(logSpinner, item);
-            }
-        });
-    };
+		return await processItemsAsync<MigrationItem, Readonly<ContentItemModels.ContentItem>>({
+			action: "Importing content items",
+			logger: data.logger,
+			parallelLimit: 1,
+			items: contentItemsToImport,
+			itemInfo: (item) => {
+				return {
+					itemType: "contentItem",
+					title: `${item.system.codename} -> ${item.system.type.codename}`,
+				};
+			},
+			processAsync: async (item, logSpinner) => {
+				return await importContentItemAsync(logSpinner, item);
+			},
+		});
+	};
 
-    return {
-        importAsync
-    };
+	return {
+		importAsync,
+	};
 }