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

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)}%`);
 }

package/lib/core/utils/run.utils.ts

@@ -1,60 +1,60 @@
-import chalk from 'chalk';
-import { match } from 'ts-pattern';
-import type { MapiAction, MapiType } from '../models/core.models.js';
-import type { LogMessage, LogSpinnerData, Logger } from '../models/log.models.js';
+import chalk from "chalk";
+import { match } from "ts-pattern";
+import type { MapiAction, MapiType } from "../models/core.models.js";
+import type { Logger, LogMessage, LogSpinnerData } from "../models/log.models.js";
 
 export async function runMapiRequestAsync<TResult>(data: {
-    readonly logger: Logger;
-    readonly logSpinner?: LogSpinnerData;
-    readonly action: MapiAction;
-    readonly type: MapiType;
-    readonly func: () => Promise<TResult>;
-    readonly itemName?: string;
+	readonly logger: Logger;
+	readonly logSpinner?: LogSpinnerData;
+	readonly action: MapiAction;
+	readonly type: MapiType;
+	readonly func: () => Promise<TResult>;
+	readonly itemName?: string;
 }): Promise<TResult> {
-    const logData: LogMessage = match(data)
-        .returnType<LogMessage>()
-        .when(
-            (data) => data.action === 'list',
-            (data) => {
-                return {
-                    message: `Fetching objects of type '${chalk.yellow(data.type)}'`,
-                    type: data.action
-                };
-            }
-        )
-        .when(
-            (data) => data.itemName,
-            (data) => {
-                return {
-                    message: `${data.type} -> ${data.itemName}`,
-                    type: data.action
-                };
-            }
-        )
-        .otherwise(() => {
-            return {
-                message: `${data.type}`,
-                type: data.action
-            };
-        });
+	const logData: LogMessage = match(data)
+		.returnType<LogMessage>()
+		.when(
+			(data) => data.action === "list",
+			(data) => {
+				return {
+					message: `Fetching objects of type '${chalk.yellow(data.type)}'`,
+					type: data.action,
+				};
+			},
+		)
+		.when(
+			(data) => data.itemName,
+			(data) => {
+				return {
+					message: `${data.type} -> ${data.itemName}`,
+					type: data.action,
+				};
+			},
+		)
+		.otherwise(() => {
+			return {
+				message: `${data.type}`,
+				type: data.action,
+			};
+		});
 
-    logSpinnerOrDefault({
-        logSpinner: data.logSpinner,
-        logger: data.logger,
-        logData: logData
-    });
+	logSpinnerOrDefault({
+		logSpinner: data.logSpinner,
+		logger: data.logger,
+		logData: logData,
+	});
 
-    return await data.func();
+	return await data.func();
 }
 
 function logSpinnerOrDefault(data: {
-    readonly logSpinner: LogSpinnerData | undefined;
-    readonly logData: LogMessage;
-    readonly logger: Logger;
+	readonly logSpinner: LogSpinnerData | undefined;
+	readonly logData: LogMessage;
+	readonly logger: Logger;
 }): void {
-    if (data.logSpinner) {
-        data.logSpinner(data.logData);
-    } else {
-        data.logger.log(data.logData);
-    }
+	if (data.logSpinner) {
+		data.logSpinner(data.logData);
+	} else {
+		data.logger.log(data.logData);
+	}
 }

package/lib/core/utils/try.utils.ts

@@ -0,0 +1,30 @@
+type Success<TData> = {
+	readonly success: true;
+	readonly data: TData;
+	readonly error?: never;
+};
+
+type Failure<TError = unknown> = {
+	readonly success: false;
+	readonly data?: never;
+	readonly error: TError;
+};
+
+export type Result<TData, TError = unknown> = Success<TData> | Failure<TError>;
+
+export async function tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T>> {
+	try {
+		const data = await fn();
+		return { success: true, data };
+	} catch (error) {
+		return { success: false, error };
+	}
+}
+
+export function tryCatch<T>(fn: () => T): Result<T> {
+	try {
+		return { success: true, data: fn() };
+	} catch (error) {
+		return { success: false, error };
+	}
+}