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

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

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

@@ -1,196 +1,199 @@
-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,
+							name: snippetElement.name,
+							type: snippetElement.type,
+							id: snippetElement.id,
+							element: snippetElement,
+						};
+
+						return flattenedElement;
+					});
+				}
+				const flattenedElement: FlattenedContentTypeElement = {
+					codename: element.codename,
+					name: element.name,
+					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 = {
+					name: contentType.name,
+					contentTypeCodename: contentType.codename,
+					contentTypeId: contentType.id,
+					elements: getContentTypeElements(contentType, contentTypeSnippets),
+				};
+
+				return importType;
+			}),
+		];
+	};
+
+	return {
+		getAllCollectionsAsync,
+		getAllLanguagesAsync,
+		getAllWorkflowsAsync,
+		getAllTaxonomiesAsync,
+		getFlattenedContentTypesAsync,
+		getEnvironmentAsync,
+		getAllAssetFoldersAsync,
+	};
 }