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

package/lib/core/utils/error.utils.ts

@@ -1,88 +1,85 @@
-import { SharedModels } from '@kontent-ai/management-sdk';
-import chalk from 'chalk';
-import { match } from 'ts-pattern';
-import { ZodError } from 'zod';
-import type { ErrorData, OriginalManagementError } from '../models/core.models.js';
+import { SharedModels } from "@kontent-ai/management-sdk";
+import chalk from "chalk";
+import { match } from "ts-pattern";
+import { ZodError } from "zod";
+import type { ErrorData, OriginalManagementError } from "../models/core.models.js";
 
 export function extractErrorData(error: unknown): ErrorData {
-    return match(error)
-        .returnType<ErrorData>()
-        .when(
-            (error) => error instanceof SharedModels.ContentManagementBaseKontentError,
-            (error) => {
-                const originalError = error.originalError as OriginalManagementError | undefined;
+	return match(error)
+		.returnType<ErrorData>()
+		.when(
+			(error) => error instanceof SharedModels.ContentManagementBaseKontentError,
+			(error) => {
+				const originalError = error.originalError as OriginalManagementError | undefined;
 
-                return {
-                    isUnknownError: false,
-                    error: error,
-                    message: `${error.message} ${error.validationErrors.map((m) => m.message).join(', ')}`,
-                    requestUrl: originalError?.response?.config?.url,
-                    requestData: originalError?.response?.config?.data
-                };
-            }
-        )
-        .when(
-            (error) => error instanceof ZodError,
-            (error) => {
-                return {
-                    isUnknownError: false,
-                    error: error,
-                    message: `Found '${chalk.red(error.issues.length)}' parsing errors: \n${error.issues.reduce<string>(
-                        (current, issue, index) => {
-                            return (current += `\n${index + 1}. ${chalk.red(issue.message)} (${chalk.yellow('path')}: ${issue.path.join(
-                                ','
-                            )})`);
-                        },
-                        ''
-                    )}`
-                };
-            }
-        )
-        .when(
-            (error) => error instanceof Error,
-            (error) => {
-                return {
-                    isUnknownError: false,
-                    error: error,
-                    message: error.message
-                };
-            }
-        )
-        .otherwise((error) => {
-            return {
-                isUnknownError: true,
-                error: error,
-                message: `Unknown error`
-            };
-        });
+				return {
+					isUnknownError: false,
+					error: error,
+					message: `${error.message} ${error.validationErrors.map((m) => m.message).join(", ")}`,
+					requestUrl: originalError?.response?.config?.url,
+					requestData: originalError?.response?.config?.data,
+				};
+			},
+		)
+		.when(
+			(error) => error instanceof ZodError,
+			(error) => {
+				const parsingErrorsMsg = error.issues.reduce<string>((current, issue, index) => {
+					const message = `\n${index + 1}. ${chalk.red(issue.message)} (${chalk.yellow("path")}: ${issue.path.join(",")})`;
+					return `${current}${message}`;
+				}, "");
+				return {
+					isUnknownError: false,
+					error: error,
+					message: `Found '${chalk.red(error.issues.length)}' parsing errors: \n${parsingErrorsMsg}`,
+				};
+			},
+		)
+		.when(
+			(error) => error instanceof Error,
+			(error) => {
+				return {
+					isUnknownError: false,
+					error: error,
+					message: error.message,
+				};
+			},
+		)
+		.otherwise((error) => {
+			return {
+				isUnknownError: true,
+				error: error,
+				message: `Unknown error`,
+			};
+		});
 }
 
 export function is404Error(error: unknown): boolean {
-    if (error instanceof SharedModels.ContentManagementBaseKontentError) {
-        const originalError = error.originalError as OriginalManagementError | undefined;
+	if (error instanceof SharedModels.ContentManagementBaseKontentError) {
+		const originalError = error.originalError as OriginalManagementError | undefined;
 
-        if (originalError?.response?.status === 404) {
-            return true;
-        }
-    }
+		if (originalError?.response?.status === 404) {
+			return true;
+		}
+	}
 
-    return false;
+	return false;
 }
 
 export function handleError(error: unknown): void {
-    const errorData = extractErrorData(error);
+	const errorData = extractErrorData(error);
 
-    if (errorData.isUnknownError) {
-        console.error(error);
-    }
+	if (errorData.isUnknownError) {
+		console.error(error);
+	}
 
-    if (errorData.requestData) {
-        console.log(`${chalk.red('Request data')}: ${errorData.requestData}`);
-    }
+	if (errorData.requestData) {
+		console.log(`${chalk.red("Request data")}: ${errorData.requestData}`);
+	}
 
-    if (errorData.requestUrl) {
-        console.log(`${chalk.red('Request url')}: ${errorData.requestUrl}`);
-    }
+	if (errorData.requestUrl) {
+		console.log(`${chalk.red("Request url")}: ${errorData.requestUrl}`);
+	}
 
-    console.error(`${chalk.red('Error:')} ${errorData.message}`);
+	console.error(`${chalk.red("Error:")} ${errorData.message}`);
 }

package/lib/core/utils/external-id.utils.ts

@@ -1,9 +1,9 @@
 export interface ExternalIdGenerator {
-    readonly assetExternalId: (codename: string) => string;
-    readonly contentItemExternalId: (codename: string) => string;
+	readonly assetExternalId: (codename: string) => string;
+	readonly contentItemExternalId: (codename: string) => string;
 }
 
 export const defaultExternalIdGenerator: ExternalIdGenerator = {
-    assetExternalId: (codename) => `asset_${codename}`,
-    contentItemExternalId: (codename) => `item_${codename}`
+	assetExternalId: (codename) => `asset_${codename}`,
+	contentItemExternalId: (codename) => `item_${codename}`,
 };

package/lib/core/utils/global.utils.ts

@@ -1,98 +1,104 @@
-import type { ITrackingEventData } from '@kontent-ai-consulting/tools-analytics';
-import { getTrackingService } from '@kontent-ai-consulting/tools-analytics';
-import { isBrowser, isNode, isWebWorker } from 'browser-or-node';
-import { format } from 'bytes';
-import { getDefaultLogger } from '../logs/loggers.js';
-import type { EnvContext } from '../models/core.models.js';
-import type { Logger } from '../models/log.models.js';
-import { extractErrorData } from './error.utils.js';
+import type { ITrackingEventData } from "@kontent-ai-consulting/tools-analytics";
+import { getTrackingService } from "@kontent-ai-consulting/tools-analytics";
+import { isBrowser, isNode, isWebWorker } from "browser-or-node";
+import { format } from "bytes";
+import { getDefaultLogger } from "../logs/loggers.js";
+import type { EnvContext } from "../models/core.models.js";
+import { MigrationToolkitError } from "../models/error.models.js";
+import type { Logger } from "../models/log.models.js";
+import { extractErrorData } from "./error.utils.js";
 
 export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
 
 export const isNotUndefined = <T>(item: T | undefined): item is T => item !== undefined;
 
-export const isString = (value: unknown): value is string => typeof value === 'string';
+export const isString = (value: unknown): value is string => typeof value === "string";
 export const isArray = <T>(value: unknown): value is Array<T> => Array.isArray(value);
 
 export function formatBytes(bytes: number): string {
-    return format(bytes) ?? 'n/a';
+	return format(bytes) ?? "n/a";
 }
 
 export function exitProgram(data: { readonly message: string }): never {
-    throw Error(data.message);
+	throw new MigrationToolkitError("exitProgram", data.message);
 }
 
 export function getCurrentEnvironment(): EnvContext {
-    if (isNode) {
-        return 'node';
-    }
-    if (isBrowser || isWebWorker) {
-        return 'browser';
-    }
-
-    throw Error(`Invalid current environment. This library can be used in node.js or in browsers.`);
+	if (isNode) {
+		return "node";
+	}
+	if (isBrowser || isWebWorker) {
+		return "browser";
+	}
+
+	throw new MigrationToolkitError(
+		"invalidEnvironment",
+		`Invalid current environment. This library can be used in node.js or in browsers.`,
+	);
 }
 
-export const defaultZipFilename: string = 'data.zip';
+export const defaultZipFilename: string = "data.zip";
 
 export async function executeWithTrackingAsync<TResult>(data: {
-    readonly func: () => Promise<TResult extends void ? void : Readonly<TResult>>;
-    readonly event: Readonly<ITrackingEventData>;
-    readonly logger?: Logger;
+	readonly func: () => Promise<TResult extends void ? void : Readonly<TResult>>;
+	readonly event: Readonly<ITrackingEventData>;
+	readonly logger?: Logger;
 }): Promise<TResult extends void ? void : Readonly<TResult>> {
-    const trackingService = getTrackingService();
-    const logger = data.logger ?? getDefaultLogger();
-
-    const event = await runTrackingFuncWithErrorHadlingAsync({
-        func: async () => {
-            return await trackingService.trackEventAsync(data.event);
-        },
-        logger: logger
-    });
-
-    try {
-        const result = await data.func();
-
-        if (event) {
-            await runTrackingFuncWithErrorHadlingAsync({
-                func: async () => {
-                    await trackingService.setEventResultAsync({
-                        eventId: event.eventId,
-                        result: 'success'
-                    });
-                },
-                logger: logger
-            });
-        }
-
-        return result;
-    } catch (error) {
-        if (event) {
-            await runTrackingFuncWithErrorHadlingAsync({
-                func: async () => {
-                    await trackingService.setEventResultAsync({
-                        eventId: event.eventId,
-                        result: 'fail'
-                    });
-                },
-                logger: logger
-            });
-        }
-
-        throw error;
-    }
+	const trackingService = getTrackingService();
+	const logger = data.logger ?? getDefaultLogger();
+
+	const event = await runTrackingFuncWithErrorHadlingAsync({
+		func: async () => {
+			return await trackingService.trackEventAsync(data.event);
+		},
+		logger: logger,
+	});
+
+	try {
+		const result = await data.func();
+
+		if (event) {
+			await runTrackingFuncWithErrorHadlingAsync({
+				func: async () => {
+					await trackingService.setEventResultAsync({
+						eventId: event.eventId,
+						result: "success",
+					});
+				},
+				logger: logger,
+			});
+		}
+
+		return result;
+	} catch (error) {
+		if (event) {
+			await runTrackingFuncWithErrorHadlingAsync({
+				func: async () => {
+					await trackingService.setEventResultAsync({
+						eventId: event.eventId,
+						result: "fail",
+					});
+				},
+				logger: logger,
+			});
+		}
+
+		throw error;
+	}
 }
 
 async function runTrackingFuncWithErrorHadlingAsync<T>(data: {
-    readonly func: () => Promise<T>;
-    readonly logger: Logger;
-}): Promise<T | void> {
-    try {
-        return await data.func();
-    } catch (trackingError) {
-        data.logger.log({
-            message: `Failed to track event. ${extractErrorData(trackingError).message}`,
-            type: 'warning'
-        });
-    }
+	readonly func: () => Promise<T>;
+	readonly logger: Logger;
+}): Promise<T | undefined> {
+	try {
+		return await data.func();
+	} catch (trackingError) {
+		data.logger.log({
+			message: `Failed to track event. ${extractErrorData(trackingError).message}`,
+			type: "warning",
+		});
+
+		return undefined;
+	}
 }

package/lib/core/utils/http.utils.ts

@@ -1,32 +1,32 @@
-import type { IRetryStrategyOptions } from '@kontent-ai/core-sdk';
-import { HttpService } from '@kontent-ai/core-sdk';
-import { match } from 'ts-pattern';
-import type { OriginalManagementError } from '../models/core.models.js';
+import type { IRetryStrategyOptions } from "@kontent-ai/core-sdk";
+import { HttpService } from "@kontent-ai/core-sdk";
+import { match } from "ts-pattern";
+import type { OriginalManagementError } from "../models/core.models.js";
 
 const rateExceededErrorCode: number = 10000;
 
 export const defaultHttpService: Readonly<HttpService> = new HttpService({
-    logErrorsToConsole: false
+	logErrorsToConsole: false,
 });
 
 export const defaultRetryStrategy: Readonly<IRetryStrategyOptions> = {
-    addJitter: true,
-    canRetryError: (err) => {
-        const originalError = err as OriginalManagementError | undefined;
-        const errorCode: number = originalError?.response?.data?.error_code ?? -1;
+	addJitter: true,
+	canRetryError: (err) => {
+		const originalError = err as OriginalManagementError | undefined;
+		const errorCode: number = originalError?.response?.data?.error_code ?? -1;
 
-        return (
-            match(errorCode)
-                // retry rate exceeded error
-                .with(rateExceededErrorCode, () => true)
-                // if error code is set, do not retry the request
-                .when(
-                    (errorCode) => errorCode >= 0,
-                    () => false
-                )
-                .otherwise(() => true)
-        );
-    },
-    maxAttempts: 3,
-    deltaBackoffMs: 1000
+		return (
+			match(errorCode)
+				// retry rate exceeded error
+				.with(rateExceededErrorCode, () => true)
+				// if error code is set, do not retry the request
+				.when(
+					(errorCode) => errorCode >= 0,
+					() => false,
+				)
+				.otherwise(() => true)
+		);
+	},
+	maxAttempts: 3,
+	deltaBackoffMs: 1000,
 };