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

package/lib/core/utils/confirm.utils.ts

@@ -1,133 +1,211 @@
-import chalk from 'chalk';
-import type { Logger } from '../models/log.models.js';
-import { getMigrationManagementClient, managementClientUtils } from './management-client-utils.js';
+import type { EnvironmentModels } from "@kontent-ai/management-sdk";
+import chalk from "chalk";
+import { match, P } from "ts-pattern";
+import { MigrationToolkitError } from "../models/error.models.js";
+import type { Logger } from "../models/log.models.js";
+import { getMigrationManagementClient, managementClientUtils } from "./management-client-utils.js";
 
 export async function confirmExportAsync(data: {
-    readonly force: boolean;
-    readonly environmentId: string;
-    readonly apiKey: string;
-    readonly logger: Logger;
-    readonly dataToExport: {
-        readonly itemsCount: number;
-    };
+	readonly force: boolean;
+	readonly environmentId: string;
+	readonly apiKey: string;
+	readonly logger: Logger;
+	readonly skipMissingReferences: boolean;
+	readonly dataToExport: {
+		readonly itemsCount: number;
+	};
 }): Promise<void> {
-    const environment = await managementClientUtils(
-        getMigrationManagementClient({
-            environmentId: data.environmentId,
-            apiKey: data.apiKey
-        }),
-        data.logger
-    ).getEnvironmentAsync();
+	const environment = await managementClientUtils(
+		getMigrationManagementClient({
+			environmentId: data.environmentId,
+			apiKey: data.apiKey,
+		}),
+		data.logger,
+	).getEnvironmentAsync();
 
-    const text: string = `Are you sure to export '${chalk.cyan(data.dataToExport.itemsCount)}' content ${getItemsPluralText(
-        data.dataToExport.itemsCount
-    )} from ${chalk.yellow(environment.name)} (${chalk.magenta(environment.environment)})?`;
+	const text = getConfirmText({
+		action: "export",
+		itemsCount: data.dataToExport.itemsCount,
+		sourceEnvironment: environment,
+		skipMissingReferences: data.skipMissingReferences,
+	});
 
-    await confirmAsync({
-        force: data.force,
-        logger: data.logger,
-        action: 'Export',
-        message: text
-    });
+	await confirmAsync({
+		force: data.force,
+		logger: data.logger,
+		action: "Export",
+		message: text,
+	});
 }
 
 export async function confirmMigrateAsync(data: {
-    readonly force: boolean;
-    readonly sourceEnvironment: {
-        readonly environmentId: string;
-        readonly apiKey: string;
-    };
-    readonly targetEnvironment: {
-        readonly environmentId: string;
-        readonly apiKey: string;
-    };
-    readonly logger: Logger;
-    readonly dataToMigrate: {
-        readonly itemsCount: number;
-    };
+	readonly force: boolean;
+	readonly sourceEnvironment: {
+		readonly environmentId: string;
+		readonly apiKey: string;
+	};
+	readonly targetEnvironment: {
+		readonly environmentId: string;
+		readonly apiKey: string;
+	};
+	readonly skipMissingReferences: boolean;
+	readonly logger: Logger;
+	readonly dataToMigrate: {
+		readonly itemsCount: number;
+	};
 }): Promise<void> {
-    const sourceEnvironment = await managementClientUtils(
-        getMigrationManagementClient({
-            environmentId: data.sourceEnvironment.environmentId,
-            apiKey: data.sourceEnvironment.apiKey
-        }),
-        data.logger
-    ).getEnvironmentAsync();
-    const targetEnvironment = await managementClientUtils(
-        getMigrationManagementClient({
-            environmentId: data.targetEnvironment.environmentId,
-            apiKey: data.targetEnvironment.apiKey
-        }),
-        data.logger
-    ).getEnvironmentAsync();
+	const sourceEnvironment = await managementClientUtils(
+		getMigrationManagementClient({
+			environmentId: data.sourceEnvironment.environmentId,
+			apiKey: data.sourceEnvironment.apiKey,
+		}),
+		data.logger,
+	).getEnvironmentAsync();
+	const targetEnvironment = await managementClientUtils(
+		getMigrationManagementClient({
+			environmentId: data.targetEnvironment.environmentId,
+			apiKey: data.targetEnvironment.apiKey,
+		}),
+		data.logger,
+	).getEnvironmentAsync();
 
-    const text: string = `Are you sure to migrate '${chalk.cyan(data.dataToMigrate.itemsCount)}' ${getItemsPluralText(
-        data.dataToMigrate.itemsCount
-    )} from ${chalk.yellow(sourceEnvironment.name)} (${chalk.magenta(sourceEnvironment.environment)}) to environment ${chalk.yellow(
-        targetEnvironment.name
-    )} (${chalk.magenta(targetEnvironment.environment)}) ?`;
+	const text = getConfirmText({
+		action: "migrate",
+		itemsCount: data.dataToMigrate.itemsCount,
+		sourceEnvironment,
+		targetEnvironment,
+		skipMissingReferences: data.skipMissingReferences,
+	});
 
-    await confirmAsync({
-        force: data.force,
-        logger: data.logger,
-        action: 'Migrate',
-        message: text
-    });
+	await confirmAsync({
+		force: data.force,
+		logger: data.logger,
+		action: "Migrate",
+		message: text,
+	});
 }
 
 export async function confirmImportAsync(data: {
-    readonly force: boolean;
-    readonly environmentId: string;
-    readonly apiKey: string;
-    readonly logger: Logger;
+	readonly force: boolean;
+	readonly environmentId: string;
+	readonly apiKey: string;
+	readonly logger: Logger;
 }): Promise<void> {
-    const environment = await managementClientUtils(
-        getMigrationManagementClient({
-            environmentId: data.environmentId,
-            apiKey: data.apiKey
-        }),
-        data.logger
-    ).getEnvironmentAsync();
+	const environment = await managementClientUtils(
+		getMigrationManagementClient({
+			environmentId: data.environmentId,
+			apiKey: data.apiKey,
+		}),
+		data.logger,
+	).getEnvironmentAsync();
 
-    const text: string = `Are you sure to import data into ${chalk.yellow(environment.name)} (${chalk.magenta(environment.environment)})?`;
+	const text = getConfirmText({
+		action: "import",
+		targetEnvironment: environment,
+		itemsCount: undefined,
+	});
 
-    await confirmAsync({
-        force: data.force,
-        logger: data.logger,
-        action: 'Import',
-        message: text
-    });
+	await confirmAsync({
+		force: data.force,
+		logger: data.logger,
+		action: "Import",
+		message: text,
+	});
 }
 
 async function confirmAsync(data: {
-    readonly action: string;
-    readonly message: string;
-    readonly force: boolean;
-    readonly logger: Logger;
+	readonly action: string;
+	readonly message: string;
+	readonly force: boolean;
+	readonly logger: Logger;
 }): Promise<void> {
-    // Prompts is imported dynamically because it's a node.js only module and would not work if user
-    // tried using this library in a browser
-    const prompts = await import('prompts');
+	// Prompts is imported dynamically because it's a node.js only module and would not work if user
+	// tried using this library in a browser
+	const prompts = await import("prompts");
 
-    if (data.force) {
-        data.logger.log({
-            type: 'info',
-            message: `Skipping confirmation`
-        });
-        return;
-    }
+	if (data.force) {
+		data.logger.log({
+			type: "info",
+			message: `Skipping confirmation`,
+		});
+		return;
+	}
 
-    const confirmed = await prompts.default({
-        type: 'confirm',
-        name: 'confirm',
-        message: `${chalk.cyan(data.action)}: ${data.message}`
-    });
+	const confirmed = await prompts.default({
+		type: "confirm",
+		name: "confirm",
+		message: `${chalk.cyan(data.action)}: ${data.message}`,
+	});
 
-    if (!confirmed.confirm) {
-        throw Error(`Confirmation refused.`);
-    }
+	if (!confirmed.confirm) {
+		throw new MigrationToolkitError("confirmationRefused", `Confirmation refused.`);
+	}
 }
 
-function getItemsPluralText(count: number): string {
-    return count === 1 ? 'item' : 'items';
+function getConfirmText({
+	action,
+	itemsCount,
+	sourceEnvironment,
+	targetEnvironment,
+	skipMissingReferences,
+}: {
+	readonly action: "export" | "import" | "migrate";
+	readonly skipMissingReferences?: boolean;
+	readonly itemsCount?: number;
+	readonly sourceEnvironment?: EnvironmentModels.EnvironmentInformationModel;
+	readonly targetEnvironment?: EnvironmentModels.EnvironmentInformationModel;
+}): string {
+	const lines: readonly string[] = [
+		`\n${"=".repeat(70)}`,
+		...match(action)
+			.returnType<readonly string[]>()
+			.with("export", () => [
+				`${chalk.cyan("📤 Source environment:")}`,
+				`  ${chalk.gray("├─")} Name:        ${chalk.yellow.bold(sourceEnvironment?.name)}`,
+				`  ${chalk.gray("├─")} Environment: ${chalk.green.bold(sourceEnvironment?.environment)}`,
+				`  ${chalk.gray("└─")} ID:          ${chalk.dim(sourceEnvironment?.id)}`,
+			])
+			.with("import", () => [
+				`${chalk.cyan("📥 Target environment:")}`,
+				`  ${chalk.gray("├─")} Name:        ${chalk.yellow.bold(targetEnvironment?.name)}`,
+				`  ${chalk.gray("├─")} Environment: ${chalk.green.bold(targetEnvironment?.environment)}`,
+				`  ${chalk.gray("└─")} ID:          ${chalk.dim(targetEnvironment?.id)}`,
+			])
+			.with("migrate", () => [
+				`${chalk.cyan("📤 Source environment:")}`,
+				`  ${chalk.gray("├─")} Name:        ${chalk.yellow.bold(sourceEnvironment?.name)}`,
+				`  ${chalk.gray("├─")} Environment: ${chalk.green.bold(sourceEnvironment?.environment)}`,
+				`  ${chalk.gray("└─")} ID:          ${chalk.dim(sourceEnvironment?.id)}`,
+				`${chalk.cyan("📥 Target environment:")}`,
+				`  ${chalk.gray("├─")} Name:        ${chalk.yellow.bold(targetEnvironment?.name)}`,
+				`  ${chalk.gray("├─")} Environment: ${chalk.green.bold(targetEnvironment?.environment)}`,
+				`  ${chalk.gray("└─")} ID:          ${chalk.dim(targetEnvironment?.id)}`,
+			])
+			.exhaustive(),
+		"\n",
+		...match(itemsCount)
+			.returnType<readonly string[]>()
+			.with(P.nonNullable, (itemsCount) => [
+				`${chalk.cyan("📦 Items to process:")}`,
+				`  ${chalk.gray("├─")} Count: ${chalk.green.bold(itemsCount)}`,
+				"",
+			])
+			.otherwise(() => []),
+		...match(action)
+			.returnType<readonly string[]>()
+			.with(P.union("export", "migrate"), () => [
+				`${chalk.cyan("⚙️  Configuration:")}`,
+				`  ${chalk.gray("└─")} Skip missing references: ${chalk.green.bold(skipMissingReferences ? "Yes" : "No")}`,
+				"",
+			])
+			.otherwise(() => []),
+		`${chalk.yellow("⚠")}  ${match(action)
+			.returnType<string>()
+			.with("export", () => "Are you sure you want to export the data?")
+			.with("import", () => "Are you sure you want to import the data?")
+			.with("migrate", () => "Are you sure you want to migrate the data?")
+			.exhaustive()}`,
+	];
+
+	return lines.join("\n");
 }

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(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}`,
 };