@kontent-ai/migration-toolkit 3.0.1 → 3.1.0

package/lib/core/models/core.models.ts

@@ -52,28 +52,28 @@ export type LanguageVariantWorkflowState =
 	  }
 	| undefined;
 
-export interface ItemInfo {
+export type ItemInfo = {
 	readonly title: string;
 	readonly itemType: MapiType | MigrationItemType;
-}
+};
 
-export interface ErrorData {
+export type ErrorData = {
 	readonly message: string;
-	readonly requestData?: string;
-	readonly requestUrl?: string;
+	readonly requestData: string | undefined;
+	readonly requestUrl: string | undefined;
 	readonly isUnknownError: boolean;
 	readonly error: unknown;
-}
+};
 
-export interface ReferencedDataInMigrationItems {
+export type ReferencedDataInMigrationItems = {
 	readonly itemCodenames: ReadonlySet<string>;
 	readonly assetCodenames: ReadonlySet<string>;
-}
+};
 
-export interface ReferencedDataInLanguageVariants {
+export type ReferencedDataInLanguageVariants = {
 	readonly itemIds: ReadonlySet<string>;
 	readonly assetIds: ReadonlySet<string>;
-}
+};
 
 type DataStateInSourceEnvironmentById<T extends Readonly<ContentItemModels.ContentItem> | Readonly<AssetModels.Asset>> = {
 	readonly id: string;
@@ -96,61 +96,61 @@ export type ItemStateInSourceEnvironmentById = DataStateInSourceEnvironmentById<
 
 export type AssetStateInSourceEnvironmentById = DataStateInSourceEnvironmentById<Readonly<AssetModels.Asset>>;
 
-export interface ItemStateInTargetEnvironmentByCodename {
+export type ItemStateInTargetEnvironmentByCodename = {
 	readonly state: TargetItemState;
 	readonly itemCodename: string;
 	readonly item: Readonly<ContentItemModels.ContentItem> | undefined;
 	readonly externalIdToUse: string;
-}
+};
 
-export interface LanguageVariantStateData {
+export type LanguageVariantStateData = {
 	readonly languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
 	readonly workflow: Readonly<WorkflowModels.Workflow> | undefined;
 	readonly workflowState: LanguageVariantWorkflowState;
-}
+};
 
-export interface LanguageVariantStateInTargetEnvironmentByCodename {
+export type LanguageVariantStateInTargetEnvironmentByCodename = {
 	readonly state: TargetItemState;
 	readonly itemCodename: string;
 	readonly languageCodename: string;
 	readonly publishedLanguageVariant: LanguageVariantStateData | undefined;
 	readonly draftLanguageVariant: LanguageVariantStateData | undefined;
-}
+};
 
-export interface AssetStateInTargetEnvironmentByCodename {
+export type AssetStateInTargetEnvironmentByCodename = {
 	readonly state: TargetItemState;
 	readonly assetCodename: string;
 	readonly asset: Readonly<AssetModels.Asset> | undefined;
 	readonly externalIdToUse: string;
-}
+};
 
-export interface PackageMetadata {
+export type PackageMetadata = {
 	readonly created: Date;
 	readonly environmentId: string;
 	readonly dataOverview: PackageDataOverview;
-}
+};
 
-export interface PackageDataOverview {
+export type PackageDataOverview = {
 	readonly contentItemsCount: number;
 	readonly assetsCount: number;
-}
+};
 
-export interface FlattenedContentTypeElement {
+export type FlattenedContentTypeElement = {
 	readonly codename: string;
 	readonly name: string | undefined;
 	readonly id: string;
 	readonly type: MigrationElementType;
 	readonly element: Readonly<ContentTypeElements.ContentTypeElementModel>;
-}
+};
 
-export interface FlattenedContentType {
+export type FlattenedContentType = {
 	readonly contentTypeCodename: string;
 	readonly name: string;
 	readonly contentTypeId: string;
 	readonly elements: readonly FlattenedContentTypeElement[];
-}
+};
 
-export interface OriginalManagementError {
+export type OriginalManagementError = {
 	readonly response?: {
 		readonly status?: number;
 		readonly config?: {
@@ -161,7 +161,7 @@ export interface OriginalManagementError {
 			readonly error_code?: number;
 		};
 	};
-}
+};
 
 export type ItemProcessingResult<InputItem, OutputItem> =
 	| {

package/lib/core/models/error.models.ts

@@ -112,7 +112,7 @@ export class InvalidValueError extends MigrationToolkitError {
 			`  ${chalk.gray("└─")} ID:       ${chalk.dim(contentType.contentTypeId)}`,
 			"",
 			`${chalk.cyan("🔧 Element:")}`,
-			`  ${chalk.gray("├─")} Name:     ${chalk.yellow.bold(element.name)}`,
+			`  ${chalk.gray("├─")} Name:     ${chalk.yellow.bold(element.name ?? "n/a")}`,
 			`  ${chalk.gray("├─")} Codename: ${chalk.yellow.bold(element.codename)}`,
 			`  ${chalk.gray("├─")} Type:     ${chalk.green.bold(element.type)}`,
 			`  ${chalk.gray("└─")} ID:       ${chalk.dim(element.id)}`,
@@ -124,7 +124,7 @@ export class InvalidValueError extends MigrationToolkitError {
 			"",
 			`${chalk.cyan("📦 Item version:")}`,
 			`  ${chalk.gray("├─")} Workflow step codename: ${chalk.yellow.bold(exportItemVersion.workflowStepCodename)}`,
-			`  ${chalk.gray("└─")} Language variant: ${chalk.yellow.bold(exportItemVersion.languageVariant.language.codename)}`,
+			`  ${chalk.gray("└─")} Language variant: ${chalk.yellow.bold(exportItemVersion.languageVariant.language.codename ?? "n/a")}`,
 			"",
 			chalk.cyan("Invalid Value:"),
 			chalk.dim(getValueToDisplay()),

package/lib/core/models/log.models.ts

@@ -16,19 +16,19 @@ export type DebugType =
 	| MapiType
 	| MapiAction;
 
-export interface LogMessage {
+export type LogMessage = {
 	readonly type?: DebugType;
 	readonly message: string;
-}
+};
 
-export interface LogSpinnerMessage extends LogMessage {
+export type LogSpinnerMessage = LogMessage & {
 	readonly prefix?: string;
-}
+};
 
 export type LogData = (data: LogMessage) => void;
 export type LogSpinnerData = (data: LogSpinnerMessage) => void;
 
-export interface Logger {
+export type Logger = {
 	readonly logWithSpinnerAsync: <T>(func: (logData: LogSpinnerData) => Promise<T>) => Promise<T>;
 	readonly log: LogData;
-}
+};

package/lib/core/models/migration.schema.ts

@@ -1,9 +1,9 @@
 import { Buffer as BufferProxy } from "buffer";
 import { z } from "zod";
 
-interface Elements {
+type Elements = {
 	readonly [key: string]: Element;
-}
+};
 
 type UrlSlugMode = "autogenerated" | "custom";
 type Reference = { readonly codename: string };

package/lib/core/utils/array.utils.ts

@@ -12,8 +12,6 @@ export function parseAsMigrationReferencesArray(value: MigrationElementValue): r
 	throw new MigrationToolkitError("invalidValue", `Value is not an array`);
 }
 
-export function findRequired<T>(array: readonly T[], predicate: (item: T, index: number) => boolean, errorMessage: string): T;
-export function findRequired<T>(array: readonly T[], predicate: (item: T, index: number) => boolean, errorMessage: () => never): T;
 export function findRequired<T>(
 	array: readonly T[],
 	predicate: (item: T, index: number) => boolean,

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

@@ -5,6 +5,13 @@ import { MigrationToolkitError } from "../models/error.models.js";
 import type { Logger } from "../models/log.models.js";
 import { getMigrationManagementClient, managementClientUtils } from "./management-client-utils.js";
 
+const maxItemsShownInPreview = 20;
+
+export type ItemPreview = {
+	readonly itemCodename: string;
+	readonly languageCodename: string;
+};
+
 export async function confirmExportAsync(data: {
 	readonly force: boolean;
 	readonly environmentId: string;
@@ -12,7 +19,7 @@ export async function confirmExportAsync(data: {
 	readonly logger: Logger;
 	readonly skipMissingReferences: boolean;
 	readonly dataToExport: {
-		readonly itemsCount: number;
+		readonly exportItems: readonly ItemPreview[];
 	};
 }): Promise<void> {
 	const environment = await managementClientUtils(
@@ -25,7 +32,8 @@ export async function confirmExportAsync(data: {
 
 	const text = getConfirmText({
 		action: "export",
-		itemsCount: data.dataToExport.itemsCount,
+		itemsCount: data.dataToExport.exportItems.length,
+		exportItems: data.dataToExport.exportItems,
 		sourceEnvironment: environment,
 		skipMissingReferences: data.skipMissingReferences,
 	});
@@ -51,7 +59,7 @@ export async function confirmMigrateAsync(data: {
 	readonly skipMissingReferences: boolean;
 	readonly logger: Logger;
 	readonly dataToMigrate: {
-		readonly itemsCount: number;
+		readonly migrateItems: readonly ItemPreview[];
 	};
 }): Promise<void> {
 	const sourceEnvironment = await managementClientUtils(
@@ -71,7 +79,8 @@ export async function confirmMigrateAsync(data: {
 
 	const text = getConfirmText({
 		action: "migrate",
-		itemsCount: data.dataToMigrate.itemsCount,
+		itemsCount: data.dataToMigrate.migrateItems.length,
+		migrateItems: data.dataToMigrate.migrateItems,
 		sourceEnvironment,
 		targetEnvironment,
 		skipMissingReferences: data.skipMissingReferences,
@@ -90,6 +99,9 @@ export async function confirmImportAsync(data: {
 	readonly environmentId: string;
 	readonly apiKey: string;
 	readonly logger: Logger;
+	readonly dataToImport: {
+		readonly importItems: readonly ItemPreview[];
+	};
 }): Promise<void> {
 	const environment = await managementClientUtils(
 		getMigrationManagementClient({
@@ -102,7 +114,8 @@ export async function confirmImportAsync(data: {
 	const text = getConfirmText({
 		action: "import",
 		targetEnvironment: environment,
-		itemsCount: undefined,
+		itemsCount: data.dataToImport.importItems.length,
+		importItems: data.dataToImport.importItems,
 	});
 
 	await confirmAsync({
@@ -145,6 +158,9 @@ async function confirmAsync(data: {
 function getConfirmText({
 	action,
 	itemsCount,
+	exportItems,
+	importItems,
+	migrateItems,
 	sourceEnvironment,
 	targetEnvironment,
 	skipMissingReferences,
@@ -152,9 +168,29 @@ function getConfirmText({
 	readonly action: "export" | "import" | "migrate";
 	readonly skipMissingReferences?: boolean;
 	readonly itemsCount?: number;
+	readonly exportItems?: readonly ItemPreview[];
+	readonly importItems?: readonly ItemPreview[];
+	readonly migrateItems?: readonly ItemPreview[];
 	readonly sourceEnvironment?: EnvironmentModels.EnvironmentInformationModel;
 	readonly targetEnvironment?: EnvironmentModels.EnvironmentInformationModel;
 }): string {
+	const previewItems: readonly ItemPreview[] = match(action)
+		.returnType<readonly ItemPreview[]>()
+		.with("export", () => exportItems ?? [])
+		.with("import", () => importItems ?? [])
+		.with("migrate", () => migrateItems ?? [])
+		.exhaustive()
+		.slice(0, maxItemsShownInPreview);
+	const remainingPreviewItemsCount: number = Math.max(
+		match(action)
+			.returnType<number>()
+			.with("export", () => exportItems?.length ?? 0)
+			.with("import", () => importItems?.length ?? 0)
+			.with("migrate", () => migrateItems?.length ?? 0)
+			.exhaustive() - previewItems.length,
+		0,
+	);
+
 	const lines: readonly string[] = [
 		`\n${"=".repeat(70)}`,
 		...match(action)
@@ -191,6 +227,35 @@ function getConfirmText({
 				"",
 			])
 			.otherwise(() => []),
+		...match(action)
+			.returnType<readonly string[]>()
+			.with(P.union("export", "import", "migrate"), (action) => [
+				...match(previewItems.length)
+					.returnType<readonly string[]>()
+					.with(
+						P.when((count) => count > 0),
+						() => [
+							`${chalk.cyan(
+								match(action)
+									.with("export", () => "🧾 Export item codenames preview:")
+									.with("import", () => "🧾 Import item codenames preview:")
+									.with("migrate", () => "🧾 Migrate item codenames preview:")
+									.exhaustive(),
+							)}`,
+							...previewItems.map((item) => `  ${chalk.gray("├─")} ${item.itemCodename} (${item.languageCodename})`),
+							...match(remainingPreviewItemsCount)
+								.returnType<readonly string[]>()
+								.with(
+									P.when((count) => count > 0),
+									(count) => [`  ${chalk.gray("└─")} and ${chalk.yellow.bold(count)} more`],
+								)
+								.otherwise(() => []),
+							"",
+						],
+					)
+					.otherwise(() => []),
+			])
+			.otherwise(() => []),
 		...match(action)
 			.returnType<readonly string[]>()
 			.with(P.union("export", "migrate"), () => [

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

@@ -32,6 +32,8 @@ export function extractErrorData(error: unknown): ErrorData {
 					isUnknownError: false,
 					error: error,
 					message: `Found '${chalk.red(error.issues.length)}' parsing errors: \n${parsingErrorsMsg}`,
+					requestData: undefined,
+					requestUrl: undefined,
 				};
 			},
 		)
@@ -42,6 +44,8 @@ export function extractErrorData(error: unknown): ErrorData {
 					isUnknownError: false,
 					error: error,
 					message: error.message,
+					requestData: undefined,
+					requestUrl: undefined,
 				};
 			},
 		)
@@ -50,6 +54,8 @@ export function extractErrorData(error: unknown): ErrorData {
 				isUnknownError: true,
 				error: error,
 				message: `Unknown error`,
+				requestData: undefined,
+				requestUrl: undefined,
 			};
 		});
 }

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

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

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

@@ -1,5 +1,4 @@
-import type { ITrackingEventData } from "@kontent-ai-consulting/tools-analytics";
-import { getTrackingService } from "@kontent-ai-consulting/tools-analytics";
+import { getTrackingService, type ITrackingEventData } from "@kontent-ai-consulting/tools-analytics";
 import { isBrowser, isNode, isWebWorker } from "browser-or-node";
 import { format } from "bytes";
 import { getDefaultLogger } from "../logs/loggers.js";

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

@@ -1,5 +1,4 @@
-import type { IRetryStrategyOptions } from "@kontent-ai/core-sdk";
-import { HttpService } from "@kontent-ai/core-sdk";
+import { HttpService, type IRetryStrategyOptions } from "@kontent-ai/core-sdk";
 import { match } from "ts-pattern";
 import type { OriginalManagementError } from "../models/core.models.js";
 

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

@@ -1,16 +1,16 @@
 import type { IRetryStrategyOptions } from "@kontent-ai/core-sdk";
-import type {
-	AssetFolderModels,
-	CollectionModels,
-	ContentTypeModels,
-	ContentTypeSnippetModels,
-	EnvironmentModels,
-	LanguageModels,
-	ManagementClient,
-	TaxonomyModels,
-	WorkflowModels,
+import {
+	type AssetFolderModels,
+	type CollectionModels,
+	type ContentTypeModels,
+	type ContentTypeSnippetModels,
+	createManagementClient,
+	type EnvironmentModels,
+	type LanguageModels,
+	type ManagementClient,
+	type TaxonomyModels,
+	type 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";
@@ -20,12 +20,12 @@ import { isNotUndefined } from "./global.utils.js";
 import { defaultHttpService, defaultRetryStrategy } from "./http.utils.js";
 import { runMapiRequestAsync } from "./run.utils.js";
 
-export interface ManagementClientConfig {
+export type ManagementClientConfig = {
 	readonly environmentId: string;
 	readonly apiKey: string;
 	readonly retryStrategy?: Readonly<IRetryStrategyOptions>;
 	readonly baseUrl?: string;
-}
+};
 
 export function getMigrationManagementClient(config: ManagementClientConfig): Readonly<ManagementClient> {
 	return createManagementClient({

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

@@ -32,9 +32,9 @@ export async function processItemsAsync<InputItem, OutputItem>(data: {
 		const limit = pLimit(data.parallelLimit);
 		let processedItemsCount: number = 1;
 
-		const requests: readonly Promise<ItemProcessingResult<InputItem, OutputItem>>[] = data.items.map((item) =>
-			limit(() => {
-				return data
+		const requests: readonly Promise<ItemProcessingResult<InputItem, OutputItem>>[] = data.items.map(async (item) =>
+			limit(async () => {
+				return await data
 					.processAsync(item, logSpinner)
 					.then<OutputItem | "404">((output) => {
 						const itemInfo = data.itemInfo(item);

package/lib/export/export.models.ts

@@ -20,23 +20,23 @@ import type { Logger } from "../core/models/log.models.js";
 import type { MigrationComponent, MigrationElementTransformData, MigrationUrlSlugMode } from "../core/models/migration.models.js";
 import type { ManagementClientConfig } from "../core/utils/management-client-utils.js";
 
-export interface ExportContextEnvironmentData {
+export type ExportContextEnvironmentData = {
 	readonly languages: readonly Readonly<LanguageModels.LanguageModel>[];
 	readonly contentTypes: readonly Readonly<FlattenedContentType>[];
 	readonly collections: readonly Readonly<CollectionModels.Collection>[];
 	readonly assetFolders: readonly Readonly<AssetFolderModels.AssetFolder>[];
 	readonly workflows: readonly Readonly<WorkflowModels.Workflow>[];
 	readonly taxonomies: readonly Readonly<TaxonomyModels.Taxonomy>[];
-}
+};
 
 export type ExportElementValue = string | number | SharedModels.ReferenceObject[] | undefined;
 
-export interface ExportElement {
+export type ExportElement = {
 	readonly value: ExportElementValue;
 	readonly components: readonly MigrationComponent[];
 	readonly urlSlugMode: MigrationUrlSlugMode | undefined;
 	readonly displayTimezone: string | undefined;
-}
+};
 
 export type ExportTransformFunc = (data: {
 	readonly typeElement: FlattenedContentTypeElement;
@@ -44,7 +44,7 @@ export type ExportTransformFunc = (data: {
 	readonly context: ExportContext;
 }) => MigrationElementTransformData;
 
-export interface ExportContext {
+export type ExportContext = {
 	readonly environmentData: ExportContextEnvironmentData;
 	readonly referencedData: ReferencedDataInLanguageVariants;
 	readonly getItemStateInSourceEnvironment: (id: string) => ItemStateInSourceEnvironmentById;
@@ -52,23 +52,23 @@ export interface ExportContext {
 	readonly exportItems: readonly ExportItem[];
 	readonly getElement: GetFlattenedElementByIds;
 	readonly exportContextOptions: ExportContextOptions;
-}
+};
 
-export interface SourceExportItem {
+export type SourceExportItem = {
 	readonly itemCodename: string;
 	readonly languageCodename: string;
-}
+};
 
-export interface ExportContextOptions {
+export type ExportContextOptions = {
 	/**
 	 * When enabled, the export process will skip missing items and assets instead of throwing errors.
 	 * Missing references will be filtered out from the exported data.
 	 * Default: false
 	 */
 	readonly skipMissingReferences?: boolean;
-}
+};
 
-export interface ExportConfig extends ManagementClientConfig {
+export type ExportConfig = ManagementClientConfig & {
 	readonly exportItems: readonly SourceExportItem[];
 	readonly logger?: Logger;
 	/**
@@ -77,23 +77,23 @@ export interface ExportConfig extends ManagementClientConfig {
 	 * Default: false
 	 */
 	readonly skipMissingReferences?: boolean;
-}
+};
 
-export interface DefaultExportContextConfig {
+export type DefaultExportContextConfig = {
 	readonly logger: Logger;
 	readonly exportItems: readonly SourceExportItem[];
 	readonly managementClient: Readonly<ManagementClient>;
 	readonly skipMissingReferences: boolean;
-}
+};
 
 export type GetFlattenedElementByIds = (contentTypeId: string, elementId: string) => FlattenedContentTypeElement;
 
-export interface ExportItemVersion {
+export type ExportItemVersion = {
 	readonly workflowStepCodename: string;
 	readonly languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant>;
-}
+};
 
-export interface ExportItem {
+export type ExportItem = {
 	readonly requestItem: SourceExportItem;
 	readonly versions: readonly ExportItemVersion[];
 	readonly contentItem: Readonly<ContentItemModels.ContentItem>;
@@ -102,4 +102,4 @@ export interface ExportItem {
 	readonly language: Readonly<LanguageModels.LanguageModel>;
 	readonly workflow: Readonly<WorkflowModels.Workflow>;
 	readonly contentType: Readonly<FlattenedContentType>;
-}
+};

package/lib/import/comparers/asset-comparer.ts

@@ -71,6 +71,10 @@ function areDescriptionsIdentical(data: {
 	readonly targetAsset: Readonly<AssetModels.Asset>;
 	readonly languages: readonly Readonly<LanguageModels.LanguageModel>[];
 }): boolean {
+	const languageComparer = (a: MigrationAssetDescription, b: MigrationAssetDescription) => {
+		return a.language.codename.localeCompare(b.language.codename);
+	};
+
 	const sourceMigrationDescriptions = (data.migrationAsset.descriptions ?? [])
 		.map<MigrationAssetDescription>((description) => {
 			return {
@@ -80,8 +84,8 @@ function areDescriptionsIdentical(data: {
 				},
 			};
 		})
-		.toSorted();
-	const targetMigrationDescriptions = mapToMigrationDescriptions(data).toSorted();
+		.toSorted(languageComparer);
+	const targetMigrationDescriptions = mapToMigrationDescriptions(data).toSorted(languageComparer);
 
 	return deepEqual(sourceMigrationDescriptions, targetMigrationDescriptions);
 }

package/lib/import/context/import-context-fetcher.ts

@@ -1,8 +1,7 @@
 import type { AssetModels, ContentItemModels, LanguageVariantModels } from "@kontent-ai/management-sdk";
 import chalk from "chalk";
 import { match } from "ts-pattern";
-import type { WorkflowStep } from "../../core/helpers/workflow-helper.js";
-import { workflowHelper as workflowHelperInit } from "../../core/helpers/workflow-helper.js";
+import { type WorkflowStep, workflowHelper as workflowHelperInit } from "../../core/helpers/workflow-helper.js";
 import type {
 	AssetStateInTargetEnvironmentByCodename,
 	ItemStateInTargetEnvironmentByCodename,
@@ -23,11 +22,11 @@ import { runMapiRequestAsync } from "../../core/utils/run.utils.js";
 import { type ExtractItemByCodename, itemsExtractionProcessor } from "../../translation/extraction/items-extraction.processor.js";
 import type { GetFlattenedElementByCodenames, ImportContext, ImportContextConfig, ImportContextEnvironmentData } from "../import.models.js";
 
-interface LanguageVariantWrapper {
+type LanguageVariantWrapper = {
 	readonly draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
 	readonly publishedLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
 	readonly migrationItem: MigrationItem;
-}
+};
 
 export async function importContextFetcherAsync(config: ImportContextConfig) {
 	const getEnvironmentDataAsync = async (): Promise<ImportContextEnvironmentData> => {