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

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

@@ -1,155 +1,155 @@
-import { Buffer as BufferProxy } from 'buffer';
-import { z } from 'zod';
+import { Buffer as BufferProxy } from "buffer";
+import { z } from "zod";
 
 interface Elements {
-    readonly [key: string]: Element;
+	readonly [key: string]: Element;
 }
 
-type UrlSlugMode = 'autogenerated' | 'custom';
+type UrlSlugMode = "autogenerated" | "custom";
 type Reference = { readonly codename: string };
 
 type Component = {
-    readonly system: {
-        readonly id: string;
-        readonly type: Reference;
-    };
-    readonly elements: Elements;
+	readonly system: {
+		readonly id: string;
+		readonly type: Reference;
+	};
+	readonly elements: Elements;
 };
 
 type ElementValue = string | undefined | number | Reference[];
 
 type Element = {
-    readonly type: ElementType;
-    readonly value?: ElementValue;
-    readonly display_timezone?: string;
-    readonly components?: readonly Component[];
-    readonly mode?: UrlSlugMode;
+	readonly type: ElementType;
+	readonly value?: ElementValue;
+	readonly display_timezone?: string;
+	readonly components?: readonly Component[];
+	readonly mode?: UrlSlugMode;
 };
 
 type ElementType =
-    | 'text'
-    | 'rich_text'
-    | 'number'
-    | 'multiple_choice'
-    | 'date_time'
-    | 'asset'
-    | 'modular_content'
-    | 'taxonomy'
-    | 'url_slug'
-    | 'custom'
-    | 'subpages';
-
-export const MigrationUrlSlugModeSchema = z.enum(['autogenerated', 'custom']).readonly();
+	| "text"
+	| "rich_text"
+	| "number"
+	| "multiple_choice"
+	| "date_time"
+	| "asset"
+	| "modular_content"
+	| "taxonomy"
+	| "url_slug"
+	| "custom"
+	| "subpages";
+
+export const MigrationUrlSlugModeSchema = z.enum(["autogenerated", "custom"]).readonly();
 export const MigrationElementTypeSchema = z
-    .enum([
-        'text',
-        'rich_text',
-        'number',
-        'multiple_choice',
-        'date_time',
-        'asset',
-        'modular_content',
-        'taxonomy',
-        'url_slug',
-        'custom',
-        'subpages'
-    ])
-    .readonly();
+	.enum([
+		"text",
+		"rich_text",
+		"number",
+		"multiple_choice",
+		"date_time",
+		"asset",
+		"modular_content",
+		"taxonomy",
+		"url_slug",
+		"custom",
+		"subpages",
+	])
+	.readonly();
 
 export const MigrationReferenceSchema = z
-    .strictObject({
-        codename: z.string().readonly()
-    })
-    .readonly();
+	.strictObject({
+		codename: z.string().readonly(),
+	})
+	.readonly();
 
 export const ScheduleSchema = z
-    .strictObject({
-        publish_time: z.string().datetime().optional().readonly(),
-        publish_display_timezone: z.string().optional().readonly(),
-        unpublish_time: z.string().datetime().optional().readonly(),
-        unpublish_display_timezone: z.string().optional().readonly()
-    })
-    .readonly();
+	.strictObject({
+		publish_time: z.string().datetime().optional().readonly(),
+		publish_display_timezone: z.string().optional().readonly(),
+		unpublish_time: z.string().datetime().optional().readonly(),
+		unpublish_display_timezone: z.string().optional().readonly(),
+	})
+	.readonly();
 
 /**
  * ZodType is needed to be specified here due to the use of 'lazy' & circular dependency between types
  * Otherwise TS has no way of statically inferring the type
  */
 export const MigrationElementsSchema: z.ZodReadonly<z.ZodType<Elements>> = z
-    .record(
-        z.string(),
-        z.lazy(() => MigrationElementSchema)
-    )
-    .readonly();
+	.record(
+		z.string(),
+		z.lazy(() => MigrationElementSchema),
+	)
+	.readonly();
 
 export const MigrationComponentSchema = z
-    .strictObject({
-        system: z.strictObject({
-            id: z.string(),
-            type: MigrationReferenceSchema
-        }),
-        elements: MigrationElementsSchema
-    })
-    .readonly();
+	.strictObject({
+		system: z.strictObject({
+			id: z.string(),
+			type: MigrationReferenceSchema,
+		}),
+		elements: MigrationElementsSchema,
+	})
+	.readonly();
 
 export const MigrationElementValueSchema = z.union([z.string(), z.undefined(), z.number(), z.array(MigrationReferenceSchema)]);
 
 export const MigrationElementSchema = z
-    .strictObject({
-        type: MigrationElementTypeSchema,
-        value: MigrationElementValueSchema.optional(),
-        display_timezone: z.string().optional(),
-        components: z.array(MigrationComponentSchema).readonly().optional(),
-        mode: MigrationUrlSlugModeSchema.optional()
-    })
-    .readonly();
+	.strictObject({
+		type: MigrationElementTypeSchema,
+		value: MigrationElementValueSchema.optional(),
+		display_timezone: z.string().optional(),
+		components: z.array(MigrationComponentSchema).readonly().optional(),
+		mode: MigrationUrlSlugModeSchema.optional(),
+	})
+	.readonly();
 
 export const MigrationItemVersionSchema = z
-    .strictObject({
-        workflow_step: MigrationReferenceSchema,
-        elements: MigrationElementsSchema,
-        schedule: ScheduleSchema.optional()
-    })
-    .readonly();
+	.strictObject({
+		workflow_step: MigrationReferenceSchema,
+		elements: MigrationElementsSchema,
+		schedule: ScheduleSchema.optional(),
+	})
+	.readonly();
 
 export const MigrationItemSystemSchema = z.strictObject({
-    codename: z.string(),
-    name: z.string(),
-    language: MigrationReferenceSchema,
-    type: MigrationReferenceSchema,
-    collection: MigrationReferenceSchema,
-    workflow: MigrationReferenceSchema
+	codename: z.string(),
+	name: z.string(),
+	language: MigrationReferenceSchema,
+	type: MigrationReferenceSchema,
+	collection: MigrationReferenceSchema,
+	workflow: MigrationReferenceSchema,
 });
 
 export const MigrationItemSchema = z
-    .strictObject({
-        system: MigrationItemSystemSchema,
-        versions: z.array(MigrationItemVersionSchema).readonly()
-    })
-    .readonly();
+	.strictObject({
+		system: MigrationItemSystemSchema,
+		versions: z.array(MigrationItemVersionSchema).readonly(),
+	})
+	.readonly();
 
 export const MigrationAssetDescriptionSchema = z
-    .strictObject({
-        language: MigrationReferenceSchema,
-        description: z.optional(z.string())
-    })
-    .readonly();
+	.strictObject({
+		language: MigrationReferenceSchema,
+		description: z.optional(z.string()),
+	})
+	.readonly();
 
 const BaseMigrationAssetSchema = z.strictObject({
-    codename: z.string(),
-    filename: z.string(),
-    title: z.string(),
-    collection: z.optional(MigrationReferenceSchema),
-    descriptions: z.optional(z.array(MigrationAssetDescriptionSchema)).readonly(),
-    folder: z.optional(MigrationReferenceSchema)
+	codename: z.string(),
+	filename: z.string(),
+	title: z.string().optional(),
+	collection: z.optional(MigrationReferenceSchema),
+	descriptions: z.optional(z.array(MigrationAssetDescriptionSchema)).readonly(),
+	folder: z.optional(MigrationReferenceSchema),
 });
 
 export const MigrationAssetSchema = BaseMigrationAssetSchema.extend({
-    binary_data: z.union([z.instanceof(BufferProxy), z.instanceof(Blob)])
+	binary_data: z.union([z.instanceof(BufferProxy), z.instanceof(Blob)]),
 }).readonly();
 
 export const ZipMigrationAssetSchema = BaseMigrationAssetSchema.extend({
-    _zipFilename: z.string()
+	_zipFilename: z.string(),
 }).readonly();
 
 export const MigrationAssetsSchema = z.array(MigrationAssetSchema).readonly();
@@ -157,8 +157,8 @@ export const ZipMigrationAssetsSchema = z.array(ZipMigrationAssetSchema).readonl
 export const MigrationItemsSchema = z.array(MigrationItemSchema).readonly();
 
 export const MigrationDataSchema = z
-    .strictObject({
-        items: MigrationItemsSchema,
-        assets: MigrationAssetsSchema
-    })
-    .readonly();
+	.strictObject({
+		items: MigrationItemsSchema,
+		assets: MigrationAssetsSchema,
+	})
+	.readonly();

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

@@ -1,42 +1,43 @@
-import type { MigrationElementValue, MigrationReference } from '../models/migration.models.js';
-import { isArray, isString } from './global.utils.js';
-
-export function parseAsMigrationReferencesArray(value: MigrationElementValue): readonly MigrationReference[] {
-    if (!value) {
-        return [];
-    }
-    if (isArray(value)) {
-        return value;
-    }
-    throw Error(`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,
-    errorMessage: string | (() => never)
-): T {
-    const item = array.find(predicate);
-
-    if (item) {
-        return item;
-    }
-
-    if (isString(errorMessage)) {
-        throw Error(errorMessage);
-    }
-    return errorMessage();
-}
-
-export async function mapAsync<Input, Result>(
-    array: readonly Input[],
-    callbackAsync: (item: Readonly<Input>, index: number, array: readonly Input[]) => Promise<Readonly<Result>>
-): Promise<readonly Result[]> {
-    const results: Result[] = [];
-    for (let i = 0; i < array.length; i++) {
-        results.push(await callbackAsync(array[i], i, array));
-    }
-    return results;
-}
+import { MigrationToolkitError } from "../models/error.models.js";
+import type { MigrationElementValue, MigrationReference } from "../models/migration.models.js";
+import { isArray, isString } from "./global.utils.js";
+
+export function parseAsMigrationReferencesArray(value: MigrationElementValue): readonly MigrationReference[] {
+	if (!value) {
+		return [];
+	}
+	if (isArray(value)) {
+		return value;
+	}
+	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,
+	errorMessage: string | (() => never),
+): T {
+	const item = array.find(predicate);
+
+	if (item) {
+		return item;
+	}
+
+	if (isString(errorMessage)) {
+		throw new MigrationToolkitError("findRequiredError", errorMessage);
+	}
+	return errorMessage();
+}
+
+export async function mapAsync<Input, Result>(
+	array: readonly Input[],
+	callbackAsync: (item: Readonly<Input>, index: number, array: readonly Input[]) => Promise<Readonly<Result>>,
+): Promise<readonly Result[]> {
+	const results: Result[] = [];
+	for (let i = 0; i < array.length; i++) {
+		results.push(await callbackAsync(array[i], i, array));
+	}
+	return results;
+}

package/lib/core/utils/binary-data.utils.ts

@@ -1,25 +1,25 @@
-import type { FileBinaryData } from '../../zip/index.js';
-import { defaultHttpService, defaultRetryStrategy } from './http.utils.js';
+import type { FileBinaryData } from "../../zip/zip.models.js";
+import { defaultHttpService, defaultRetryStrategy } from "./http.utils.js";
 
 export async function getBinaryDataFromUrlAsync(url: string): Promise<{ readonly data: FileBinaryData; readonly contentLength: number }> {
-    // temp fix for Kontent.ai Repository not validating url
-    const fixedUrl = url.replace('#', '%23');
+	// temp fix for Kontent.ai Repository not validating url
+	const fixedUrl = url.replace("#", "%23");
 
-    const response = await defaultHttpService.getAsync<FileBinaryData>(
-        {
-            url: fixedUrl
-        },
-        {
-            responseType: 'arraybuffer',
-            retryStrategy: defaultRetryStrategy
-        }
-    );
+	const response = await defaultHttpService.getAsync<FileBinaryData>(
+		{
+			url: fixedUrl,
+		},
+		{
+			responseType: "arraybuffer",
+			retryStrategy: defaultRetryStrategy,
+		},
+	);
 
-    const contentLength = +(response.headers.find((m) => m.header.toLowerCase() === 'content-length')?.value ?? 0);
+	const contentLength = +(response.headers.find((m) => m.header.toLowerCase() === "content-length")?.value ?? 0);
 
-    return { data: response.data, contentLength: contentLength };
+	return { data: response.data, contentLength: contentLength };
 }
 
 export function geSizeInBytes(data: FileBinaryData): number {
-    return data instanceof Blob ? data.size : data.byteLength;
+	return data instanceof Blob ? data.size : data.byteLength;
 }

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

@@ -1,133 +1,134 @@
-import chalk from 'chalk';
-import type { Logger } from '../models/log.models.js';
-import { getMigrationManagementClient, managementClientUtils } from './management-client-utils.js';
+import chalk from "chalk";
+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 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: 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)})?`;
 
-    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 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: 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)}) ?`;
 
-    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: string = `Are you sure to import data into ${chalk.yellow(environment.name)} (${chalk.magenta(environment.environment)})?`;
 
-    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';
+	return count === 1 ? "item" : "items";
 }