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

package/lib/core/utils/management-client-utils.ts

@@ -1,196 +1,196 @@
-import type { IRetryStrategyOptions } from '@kontent-ai/core-sdk';
+import type { IRetryStrategyOptions } from "@kontent-ai/core-sdk";
 import type {
-    AssetFolderModels,
-    CollectionModels,
-    ContentTypeModels,
-    ContentTypeSnippetModels,
-    EnvironmentModels,
-    LanguageModels,
-    ManagementClient,
-    TaxonomyModels,
-    WorkflowModels
-} from '@kontent-ai/management-sdk';
-import { createManagementClient } from '@kontent-ai/management-sdk';
-import chalk from 'chalk';
-import { coreConfig } from '../config.js';
-import type { FlattenedContentType, FlattenedContentTypeElement } from '../models/core.models.js';
-import type { LogSpinnerData, Logger } from '../models/log.models.js';
-import { findRequired } from './array.utils.js';
-import { isNotUndefined } from './global.utils.js';
-import { defaultHttpService, defaultRetryStrategy } from './http.utils.js';
-import { runMapiRequestAsync } from './run.utils.js';
+	AssetFolderModels,
+	CollectionModels,
+	ContentTypeModels,
+	ContentTypeSnippetModels,
+	EnvironmentModels,
+	LanguageModels,
+	ManagementClient,
+	TaxonomyModels,
+	WorkflowModels,
+} from "@kontent-ai/management-sdk";
+import { createManagementClient } from "@kontent-ai/management-sdk";
+import chalk from "chalk";
+import { coreConfig } from "../config.js";
+import type { FlattenedContentType, FlattenedContentTypeElement } from "../models/core.models.js";
+import type { Logger, LogSpinnerData } from "../models/log.models.js";
+import { findRequired } from "./array.utils.js";
+import { isNotUndefined } from "./global.utils.js";
+import { defaultHttpService, defaultRetryStrategy } from "./http.utils.js";
+import { runMapiRequestAsync } from "./run.utils.js";
 
 export interface ManagementClientConfig {
-    readonly environmentId: string;
-    readonly apiKey: string;
-    readonly retryStrategy?: Readonly<IRetryStrategyOptions>;
-    readonly baseUrl?: string;
+	readonly environmentId: string;
+	readonly apiKey: string;
+	readonly retryStrategy?: Readonly<IRetryStrategyOptions>;
+	readonly baseUrl?: string;
 }
 
 export function getMigrationManagementClient(config: ManagementClientConfig): Readonly<ManagementClient> {
-    return createManagementClient({
-        environmentId: config.environmentId,
-        retryStrategy: config.retryStrategy ?? defaultRetryStrategy,
-        httpService: defaultHttpService,
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-        headers: [
-            {
-                header: coreConfig.kontentTrackingHeaderName,
-                value: coreConfig.kontentTrackingHeaderValue
-            }
-        ]
-    });
+	return createManagementClient({
+		environmentId: config.environmentId,
+		retryStrategy: config.retryStrategy ?? defaultRetryStrategy,
+		httpService: defaultHttpService,
+		apiKey: config.apiKey,
+		baseUrl: config.baseUrl,
+		headers: [
+			{
+				header: coreConfig.kontentTrackingHeaderName,
+				value: coreConfig.kontentTrackingHeaderValue,
+			},
+		],
+	});
 }
 
 export function managementClientUtils(client: Readonly<ManagementClient>, logger: Logger) {
-    const getEnvironmentAsync = async (): Promise<EnvironmentModels.EnvironmentInformationModel> => {
-        return (await client.environmentInformation().toPromise()).data.project;
-    };
-
-    const getAllLanguagesAsync = async (logSpinner: LogSpinnerData): Promise<readonly LanguageModels.LanguageModel[]> => {
-        return await runMapiRequestAsync({
-            logSpinner: logSpinner,
-            logger: logger,
-            func: async () => (await client.listLanguages().toAllPromise()).data.items,
-            action: 'list',
-            type: 'language'
-        });
-    };
-
-    const getAllCollectionsAsync = async (logSpinner: LogSpinnerData): Promise<readonly CollectionModels.Collection[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listCollections().toPromise()).data.collections,
-            action: 'list',
-            type: 'collection'
-        });
-    };
-
-    const getAllWorkflowsAsync = async (logSpinner: LogSpinnerData): Promise<readonly WorkflowModels.Workflow[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listWorkflows().toPromise()).data,
-            action: 'list',
-            type: 'workflow'
-        });
-    };
-
-    const getAllTaxonomiesAsync = async (logSpinner: LogSpinnerData): Promise<readonly TaxonomyModels.Taxonomy[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listTaxonomies().toAllPromise()).data.items,
-            action: 'list',
-            type: 'taxonomy'
-        });
-    };
-
-    const getAllAssetFoldersAsync = async (logSpinner: LogSpinnerData): Promise<readonly AssetFolderModels.AssetFolder[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listAssetFolders().toPromise()).data.items,
-            action: 'list',
-            type: 'assetFolder'
-        });
-    };
-
-    const getContentTypeElements = (
-        contentType: ContentTypeModels.ContentType,
-        contentTypeSnippets: readonly ContentTypeSnippetModels.ContentTypeSnippet[]
-    ): readonly FlattenedContentTypeElement[] => {
-        return contentType.elements
-            .flatMap((element) => {
-                if (!element.codename || !element.id) {
-                    return undefined;
-                }
-
-                if (element.type === 'guidelines') {
-                    return undefined;
-                }
-
-                if (element.type === 'snippet') {
-                    const snippetElement = element;
-
-                    // replace snippet element with actual elements
-                    const contentTypeSnippet = findRequired(
-                        contentTypeSnippets,
-                        (snippet) => snippet.id === snippetElement.snippet.id,
-                        `Could not find content type snippet for element. This snippet is referenced in type '${chalk.red(
-                            contentType.codename
-                        )}'`
-                    );
-
-                    return contentTypeSnippet.elements.map((snippetElement) => {
-                        if (snippetElement.type === 'guidelines' || snippetElement.type === 'snippet') {
-                            return undefined;
-                        }
-                        if (!snippetElement.codename || !snippetElement.id) {
-                            return undefined;
-                        }
-
-                        const flattenedElement: FlattenedContentTypeElement = {
-                            codename: snippetElement.codename,
-                            type: snippetElement.type,
-                            id: snippetElement.id,
-                            element: snippetElement
-                        };
-
-                        return flattenedElement;
-                    });
-                }
-                const flattenedElement: FlattenedContentTypeElement = {
-                    codename: element.codename,
-                    id: element.id,
-                    type: element.type,
-                    element: element
-                };
-
-                return flattenedElement;
-            })
-            .filter(isNotUndefined);
-    };
-
-    const getFlattenedContentTypesAsync = async (logSpinner: LogSpinnerData): Promise<readonly FlattenedContentType[]> => {
-        const contentTypes = await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listContentTypes().toAllPromise()).data.items,
-            action: 'list',
-            type: 'contentType'
-        });
-
-        const contentTypeSnippets = await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listContentTypeSnippets().toAllPromise()).data.items,
-            action: 'list',
-            type: 'contentTypeSnippet'
-        });
-
-        return [
-            ...contentTypes.map((contentType) => {
-                const importType: FlattenedContentType = {
-                    contentTypeCodename: contentType.codename,
-                    contentTypeId: contentType.id,
-                    elements: getContentTypeElements(contentType, contentTypeSnippets)
-                };
-
-                return importType;
-            })
-        ];
-    };
-
-    return {
-        getAllCollectionsAsync,
-        getAllLanguagesAsync,
-        getAllWorkflowsAsync,
-        getAllTaxonomiesAsync,
-        getFlattenedContentTypesAsync,
-        getEnvironmentAsync,
-        getAllAssetFoldersAsync
-    };
+	const getEnvironmentAsync = async (): Promise<EnvironmentModels.EnvironmentInformationModel> => {
+		return (await client.environmentInformation().toPromise()).data.project;
+	};
+
+	const getAllLanguagesAsync = async (logSpinner: LogSpinnerData): Promise<readonly LanguageModels.LanguageModel[]> => {
+		return await runMapiRequestAsync({
+			logSpinner: logSpinner,
+			logger: logger,
+			func: async () => (await client.listLanguages().toAllPromise()).data.items,
+			action: "list",
+			type: "language",
+		});
+	};
+
+	const getAllCollectionsAsync = async (logSpinner: LogSpinnerData): Promise<readonly CollectionModels.Collection[]> => {
+		return await runMapiRequestAsync({
+			logger: logger,
+			logSpinner: logSpinner,
+			func: async () => (await client.listCollections().toPromise()).data.collections,
+			action: "list",
+			type: "collection",
+		});
+	};
+
+	const getAllWorkflowsAsync = async (logSpinner: LogSpinnerData): Promise<readonly WorkflowModels.Workflow[]> => {
+		return await runMapiRequestAsync({
+			logger: logger,
+			logSpinner: logSpinner,
+			func: async () => (await client.listWorkflows().toPromise()).data,
+			action: "list",
+			type: "workflow",
+		});
+	};
+
+	const getAllTaxonomiesAsync = async (logSpinner: LogSpinnerData): Promise<readonly TaxonomyModels.Taxonomy[]> => {
+		return await runMapiRequestAsync({
+			logger: logger,
+			logSpinner: logSpinner,
+			func: async () => (await client.listTaxonomies().toAllPromise()).data.items,
+			action: "list",
+			type: "taxonomy",
+		});
+	};
+
+	const getAllAssetFoldersAsync = async (logSpinner: LogSpinnerData): Promise<readonly AssetFolderModels.AssetFolder[]> => {
+		return await runMapiRequestAsync({
+			logger: logger,
+			logSpinner: logSpinner,
+			func: async () => (await client.listAssetFolders().toPromise()).data.items,
+			action: "list",
+			type: "assetFolder",
+		});
+	};
+
+	const getContentTypeElements = (
+		contentType: ContentTypeModels.ContentType,
+		contentTypeSnippets: readonly ContentTypeSnippetModels.ContentTypeSnippet[],
+	): readonly FlattenedContentTypeElement[] => {
+		return contentType.elements
+			.flatMap((element) => {
+				if (!(element.codename && element.id)) {
+					return undefined;
+				}
+
+				if (element.type === "guidelines") {
+					return undefined;
+				}
+
+				if (element.type === "snippet") {
+					const snippetElement = element;
+
+					// replace snippet element with actual elements
+					const contentTypeSnippet = findRequired(
+						contentTypeSnippets,
+						(snippet) => snippet.id === snippetElement.snippet.id,
+						`Could not find content type snippet for element. This snippet is referenced in type '${chalk.red(
+							contentType.codename,
+						)}'`,
+					);
+
+					return contentTypeSnippet.elements.map((snippetElement) => {
+						if (snippetElement.type === "guidelines" || snippetElement.type === "snippet") {
+							return undefined;
+						}
+						if (!(snippetElement.codename && snippetElement.id)) {
+							return undefined;
+						}
+
+						const flattenedElement: FlattenedContentTypeElement = {
+							codename: snippetElement.codename,
+							type: snippetElement.type,
+							id: snippetElement.id,
+							element: snippetElement,
+						};
+
+						return flattenedElement;
+					});
+				}
+				const flattenedElement: FlattenedContentTypeElement = {
+					codename: element.codename,
+					id: element.id,
+					type: element.type,
+					element: element,
+				};
+
+				return flattenedElement;
+			})
+			.filter(isNotUndefined);
+	};
+
+	const getFlattenedContentTypesAsync = async (logSpinner: LogSpinnerData): Promise<readonly FlattenedContentType[]> => {
+		const contentTypes = await runMapiRequestAsync({
+			logger: logger,
+			logSpinner: logSpinner,
+			func: async () => (await client.listContentTypes().toAllPromise()).data.items,
+			action: "list",
+			type: "contentType",
+		});
+
+		const contentTypeSnippets = await runMapiRequestAsync({
+			logger: logger,
+			logSpinner: logSpinner,
+			func: async () => (await client.listContentTypeSnippets().toAllPromise()).data.items,
+			action: "list",
+			type: "contentTypeSnippet",
+		});
+
+		return [
+			...contentTypes.map((contentType) => {
+				const importType: FlattenedContentType = {
+					contentTypeCodename: contentType.codename,
+					contentTypeId: contentType.id,
+					elements: getContentTypeElements(contentType, contentTypeSnippets),
+				};
+
+				return importType;
+			}),
+		];
+	};
+
+	return {
+		getAllCollectionsAsync,
+		getAllLanguagesAsync,
+		getAllWorkflowsAsync,
+		getAllTaxonomiesAsync,
+		getFlattenedContentTypesAsync,
+		getEnvironmentAsync,
+		getAllAssetFoldersAsync,
+	};
 }

package/lib/core/utils/processing-utils.ts

@@ -1,101 +1,101 @@
-import chalk from 'chalk';
-import pLimit from 'p-limit';
-import type { ItemInfo, ItemProcessingResult } from '../models/core.models.js';
-import type { LogSpinnerData, Logger } from '../models/log.models.js';
+import chalk from "chalk";
+import pLimit from "p-limit";
+import type { ItemInfo, ItemProcessingResult } from "../models/core.models.js";
+import type { Logger, LogSpinnerData } from "../models/log.models.js";
 
 type ProcessSetAction =
-    | 'Fetching assets'
-    | 'Downloading assets'
-    | 'Fetching content items'
-    | 'Preparing content items & language variants'
-    | 'Importing content items'
-    | 'Importing language variants'
-    | 'Fetching language variants'
-    | 'Upserting assets'
-    | 'Uploading assets';
+	| "Fetching assets"
+	| "Downloading assets"
+	| "Fetching content items"
+	| "Preparing content items & language variants"
+	| "Importing content items"
+	| "Importing language variants"
+	| "Fetching language variants"
+	| "Upserting assets"
+	| "Uploading assets";
 
 export async function processItemsAsync<InputItem, OutputItem>(data: {
-    readonly action: ProcessSetAction;
-    readonly logger: Logger;
-    readonly items: Readonly<InputItem[]>;
-    readonly parallelLimit: number;
-    readonly processAsync: (item: Readonly<InputItem>, logSpinner: LogSpinnerData) => Promise<Readonly<OutputItem> | '404'>;
-    readonly itemInfo: (item: Readonly<InputItem>) => ItemInfo;
+	readonly action: ProcessSetAction;
+	readonly logger: Logger;
+	readonly items: Readonly<InputItem[]>;
+	readonly parallelLimit: number;
+	readonly processAsync: (item: Readonly<InputItem>, logSpinner: LogSpinnerData) => Promise<Readonly<OutputItem> | "404">;
+	readonly itemInfo: (item: Readonly<InputItem>) => ItemInfo;
 }): Promise<readonly ItemProcessingResult<InputItem, OutputItem>[]> {
-    if (!data.items.length) {
-        return [];
-    }
+	if (!data.items.length) {
+		return [];
+	}
 
-    const firstItemInfo = data.itemInfo(data.items[0]);
+	const firstItemInfo = data.itemInfo(data.items[0]);
 
-    return await data.logger.logWithSpinnerAsync(async (logSpinner) => {
-        const limit = pLimit(data.parallelLimit);
-        let processedItemsCount: number = 1;
+	return await data.logger.logWithSpinnerAsync(async (logSpinner) => {
+		const limit = pLimit(data.parallelLimit);
+		let processedItemsCount: number = 1;
 
-        const requests: readonly Promise<ItemProcessingResult<InputItem, OutputItem>>[] = data.items.map((item) =>
-            limit(() => {
-                return data
-                    .processAsync(item, logSpinner)
-                    .then<OutputItem | '404'>((output) => {
-                        const itemInfo = data.itemInfo(item);
-                        const prefix = getPercentagePrefix(processedItemsCount, data.items.length);
+		const requests: readonly Promise<ItemProcessingResult<InputItem, OutputItem>>[] = data.items.map((item) =>
+			limit(() => {
+				return data
+					.processAsync(item, logSpinner)
+					.then<OutputItem | "404">((output) => {
+						const itemInfo = data.itemInfo(item);
+						const prefix = getPercentagePrefix(processedItemsCount, data.items.length);
 
-                        logSpinner({
-                            prefix: prefix,
-                            message: itemInfo.title,
-                            type: itemInfo.itemType
-                        });
+						logSpinner({
+							prefix: prefix,
+							message: itemInfo.title,
+							type: itemInfo.itemType,
+						});
 
-                        processedItemsCount++;
-                        return output;
-                    })
-                    .then<ItemProcessingResult<InputItem, OutputItem>>((outputItem) => {
-                        if (outputItem === '404') {
-                            return {
-                                state: '404',
-                                inputItem: item
-                            };
-                        }
-                        return {
-                            inputItem: item,
-                            outputItem: outputItem,
-                            state: 'valid'
-                        };
-                    })
-                    .catch<ItemProcessingResult<InputItem, OutputItem>>((error) => {
-                        return {
-                            state: 'error',
-                            inputItem: item,
-                            error: error
-                        };
-                    });
-            })
-        );
+						processedItemsCount++;
+						return output;
+					})
+					.then<ItemProcessingResult<InputItem, OutputItem>>((outputItem) => {
+						if (outputItem === "404") {
+							return {
+								state: "404",
+								inputItem: item,
+							};
+						}
+						return {
+							inputItem: item,
+							outputItem: outputItem,
+							state: "valid",
+						};
+					})
+					.catch<ItemProcessingResult<InputItem, OutputItem>>((error) => {
+						return {
+							state: "error",
+							inputItem: item,
+							error: error,
+						};
+					});
+			}),
+		);
 
-        // log processing of first item as progress is set after each item finishes
-        logSpinner({
-            prefix: getPercentagePrefix(0, data.items.length),
-            message: firstItemInfo.title,
-            type: firstItemInfo.itemType
-        });
+		// log processing of first item as progress is set after each item finishes
+		logSpinner({
+			prefix: getPercentagePrefix(0, data.items.length),
+			message: firstItemInfo.title,
+			type: firstItemInfo.itemType,
+		});
 
-        // Only '<parallelLimit>' promises at a time
-        const resultItems = await Promise.all(requests);
+		// Only '<parallelLimit>' promises at a time
+		const resultItems = await Promise.all(requests);
 
-        const failedItemsCount = resultItems.filter((m) => m.state === 'error').length;
-        const failedText = failedItemsCount ? ` Failed '${chalk.red(failedItemsCount)}' items` : ``;
+		const failedItemsCount = resultItems.filter((m) => m.state === "error").length;
+		const failedText = failedItemsCount ? ` Failed '${chalk.red(failedItemsCount)}' items` : ``;
 
-        logSpinner({
-            type: 'info',
-            message: `Completed '${chalk.yellow(data.action)}'. Successfully processed '${chalk.green(
-                resultItems.filter((m) => m.state === 'valid').length
-            )}' items.${failedText}`
-        });
+		logSpinner({
+			type: "info",
+			message: `Completed '${chalk.yellow(data.action)}'. Successfully processed '${chalk.green(
+				resultItems.filter((m) => m.state === "valid").length,
+			)}' items.${failedText}`,
+		});
 
-        return resultItems;
-    });
+		return resultItems;
+	});
 }
 
 function getPercentagePrefix(processedItems: number, totalCount: number): string {
-    return chalk.gray(`${Math.round((processedItems / totalCount) * 100)}%`);
+	return chalk.gray(`${Math.round((processedItems / totalCount) * 100)}%`);
 }