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

package/lib/translation/transforms/import-transforms.ts

@@ -1,9 +1,10 @@
-import type { LanguageVariantElements, SharedContracts } from '@kontent-ai/management-sdk';
-import { LanguageVariantElementsBuilder } from '@kontent-ai/management-sdk';
-import type { MigrationElementTransformData, MigrationElementType, MigrationItem } from '../../core/index.js';
-import { isString, parseAsMigrationReferencesArray } from '../../core/index.js';
-import type { ImportContext, ImportTransformFunc } from '../../import/index.js';
-import { richTextProcessor } from '../helpers/rich-text.processor.js';
+import type { LanguageVariantElements, SharedContracts } from "@kontent-ai/management-sdk";
+import { LanguageVariantElementsBuilder } from "@kontent-ai/management-sdk";
+import type { MigrationElementTransformData, MigrationElementType, MigrationItem } from "../../core/models/migration.models.js";
+import { parseAsMigrationReferencesArray } from "../../core/utils/array.utils.js";
+import { isString } from "../../core/utils/global.utils.js";
+import type { ImportContext, ImportTransformFunc } from "../../import/import.models.js";
+import { richTextProcessor } from "../helpers/rich-text.processor.js";
 
 const elementsBuilder = new LanguageVariantElementsBuilder();
 
@@ -12,202 +13,198 @@ const elementsBuilder = new LanguageVariantElementsBuilder();
  * Kontent.ai Management API understands
  */
 export const importTransforms: Readonly<Record<MigrationElementType, ImportTransformFunc>> = {
-    subpages: (data) => {
-        return elementsBuilder.linkedItemsElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: parseAsMigrationReferencesArray(data.elementData.value).map((m) => {
-                return {
-                    codename: m.codename
-                };
-            })
-        });
-    },
-    asset: (data) => {
-        const assetReferences = parseAsMigrationReferencesArray(data.elementData.value)
-            .map((reference) => reference.codename)
-            .map<Readonly<SharedContracts.IReferenceObjectContract>>((codename) => {
-                const assetState = data.importContext.getAssetStateInTargetEnvironment(codename);
-
-                // only reference with external_id if item does not exist in target env
-                // API currently only supports referencing assets by ids only, not by codenames
-                return {
-                    id: assetState.asset ? assetState.asset.id : undefined,
-                    external_id: assetState.asset ? undefined : assetState.externalIdToUse
-                };
-            });
-
-        return elementsBuilder.assetElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: assetReferences
-        });
-    },
-    custom: (data) => {
-        return elementsBuilder.customElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null
-        });
-    },
-    date_time: (data) => {
-        return elementsBuilder.dateTimeElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null,
-            display_timezone: data.elementData.display_timezone ?? null
-        });
-    },
-    modular_content: (data) => {
-        const linkedItemReferences = parseAsMigrationReferencesArray(data.elementData.value)
-            .map((reference) => reference.codename)
-            .map<Readonly<SharedContracts.IReferenceObjectContract>>((codename) => {
-                const itemState = data.importContext.getItemStateInTargetEnvironment(codename);
-
-                // only reference with external_id if item does not exist in target env
-                return {
-                    codename: itemState.item ? itemState.item.codename : undefined,
-                    external_id: itemState.item ? undefined : itemState.externalIdToUse
-                };
-            });
-
-        return elementsBuilder.linkedItemsElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: linkedItemReferences
-        });
-    },
-    multiple_choice: (data) => {
-        return elementsBuilder.multipleChoiceElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: parseAsMigrationReferencesArray(data.elementData.value).map((m) => {
-                return {
-                    codename: m.codename
-                };
-            })
-        });
-    },
-    number: (data) => {
-        return elementsBuilder.numberElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: data.elementData.value ? +data.elementData.value : null
-        });
-    },
-    rich_text: (data) => {
-        return elementsBuilder.richTextElement({
-            element: {
-                codename: data.elementCodename
-            },
-            components: mapComponents({
-                importContext: data.importContext,
-                migrationItems: data.migrationItems,
-                elementData: data.elementData
-            }),
-            value:
-                processImportRichTextHtmlValue({
-                    elementData: data.elementData,
-                    importContext: data.importContext,
-                    migrationItems: data.migrationItems
-                }) ?? null
-        });
-    },
-    taxonomy: (data) => {
-        return elementsBuilder.taxonomyElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: parseAsMigrationReferencesArray(data.elementData.value).map((m) => {
-                return {
-                    codename: m.codename
-                };
-            })
-        });
-    },
-    text: (data) => {
-        return elementsBuilder.textElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null
-        });
-    },
-    url_slug: (data) => {
-        return elementsBuilder.urlSlugElement({
-            element: {
-                codename: data.elementCodename
-            },
-            value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null,
-            mode: data.elementData.mode ?? 'autogenerated'
-        });
-    }
+	subpages: (data) => {
+		return elementsBuilder.linkedItemsElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: parseAsMigrationReferencesArray(data.elementData.value).map((m) => {
+				return {
+					codename: m.codename,
+				};
+			}),
+		});
+	},
+	asset: (data) => {
+		const assetReferences = parseAsMigrationReferencesArray(data.elementData.value)
+			.map((reference) => reference.codename)
+			.map<Readonly<SharedContracts.IReferenceObjectContract>>((codename) => {
+				const assetState = data.importContext.getAssetStateInTargetEnvironment(codename);
+
+				// only reference with external_id if item does not exist in target env
+				// API currently only supports referencing assets by ids only, not by codenames
+				return {
+					id: assetState.asset ? assetState.asset.id : undefined,
+					external_id: assetState.asset ? undefined : assetState.externalIdToUse,
+				};
+			});
+
+		return elementsBuilder.assetElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: assetReferences,
+		});
+	},
+	custom: (data) => {
+		return elementsBuilder.customElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null,
+		});
+	},
+	date_time: (data) => {
+		return elementsBuilder.dateTimeElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null,
+			display_timezone: data.elementData.display_timezone ?? null,
+		});
+	},
+	modular_content: (data) => {
+		const linkedItemReferences = parseAsMigrationReferencesArray(data.elementData.value)
+			.map((reference) => reference.codename)
+			.map<Readonly<SharedContracts.IReferenceObjectContract>>((codename) => {
+				const itemState = data.importContext.getItemStateInTargetEnvironment(codename);
+
+				// only reference with external_id if item does not exist in target env
+				return {
+					codename: itemState.item ? itemState.item.codename : undefined,
+					external_id: itemState.item ? undefined : itemState.externalIdToUse,
+				};
+			});
+
+		return elementsBuilder.linkedItemsElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: linkedItemReferences,
+		});
+	},
+	multiple_choice: (data) => {
+		return elementsBuilder.multipleChoiceElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: parseAsMigrationReferencesArray(data.elementData.value).map((m) => {
+				return {
+					codename: m.codename,
+				};
+			}),
+		});
+	},
+	number: (data) => {
+		return elementsBuilder.numberElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: data.elementData.value ? +data.elementData.value : null,
+		});
+	},
+	rich_text: (data) => {
+		return elementsBuilder.richTextElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			components: mapComponents({
+				importContext: data.importContext,
+				migrationItems: data.migrationItems,
+				elementData: data.elementData,
+			}),
+			value:
+				processImportRichTextHtmlValue({
+					elementData: data.elementData,
+					importContext: data.importContext,
+					migrationItems: data.migrationItems,
+				}) ?? null,
+		});
+	},
+	taxonomy: (data) => {
+		return elementsBuilder.taxonomyElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: parseAsMigrationReferencesArray(data.elementData.value).map((m) => {
+				return {
+					codename: m.codename,
+				};
+			}),
+		});
+	},
+	text: (data) => {
+		return elementsBuilder.textElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null,
+		});
+	},
+	url_slug: (data) => {
+		return elementsBuilder.urlSlugElement({
+			element: {
+				codename: data.elementCodename,
+			},
+			value: data.elementData.value && isString(data.elementData.value) ? data.elementData.value : null,
+			mode: data.elementData.mode ?? "autogenerated",
+		});
+	},
 };
 
 function mapComponents(data: {
-    readonly elementData: MigrationElementTransformData;
-    readonly importContext: ImportContext;
-    readonly migrationItems: readonly MigrationItem[];
+	readonly elementData: MigrationElementTransformData;
+	readonly importContext: ImportContext;
+	readonly migrationItems: readonly MigrationItem[];
 }): LanguageVariantElements.IRichTextComponent[] {
-    return (data.elementData.components ?? []).map((component) => {
-        const mappedComponent: Readonly<LanguageVariantElements.IRichTextComponent> = {
-            id: component.system.id,
-            type: {
-                codename: component.system.type.codename
-            },
-            elements: Object.entries(component.elements).map(([key, element]) => {
-                const transformedElementValue = importTransforms[element.type]({
-                    elementCodename: key,
-                    importContext: data.importContext,
-                    migrationItems: data.migrationItems,
-                    elementData: element
-                });
-
-                return transformedElementValue;
-            })
-        };
-
-        return mappedComponent;
-    });
+	return (data.elementData.components ?? []).map((component) => {
+		const mappedComponent: Readonly<LanguageVariantElements.IRichTextComponent> = {
+			id: component.system.id,
+			type: {
+				codename: component.system.type.codename,
+			},
+			elements: Object.entries(component.elements).map(([key, element]) => {
+				const transformedElementValue = importTransforms[element.type]({
+					elementCodename: key,
+					importContext: data.importContext,
+					migrationItems: data.migrationItems,
+					elementData: element,
+				});
+
+				return transformedElementValue;
+			}),
+		};
+
+		return mappedComponent;
+	});
 }
 
 function processImportRichTextHtmlValue(data: {
-    readonly elementData: MigrationElementTransformData;
-    readonly importContext: ImportContext;
-    readonly migrationItems: readonly MigrationItem[];
+	readonly elementData: MigrationElementTransformData;
+	readonly importContext: ImportContext;
+	readonly migrationItems: readonly MigrationItem[];
 }): string | undefined {
-    if (!data.elementData) {
-        return undefined;
-    }
-
-    let richTextHtml: string = data.elementData.value && isString(data.elementData.value) ? data.elementData.value : '';
+	let richTextHtml: string = data.elementData.value && isString(data.elementData.value) ? data.elementData.value : "";
 
-    // replace item codenames with existing codename or external_id
-    richTextHtml = richTextProcessor().processItemCodenames(richTextHtml, (codename) => {
-        return data.importContext.getItemStateInTargetEnvironment(codename);
-    }).html;
+	// replace item codenames with existing codename or external_id
+	richTextHtml = richTextProcessor().processItemCodenames(richTextHtml, (codename) => {
+		return data.importContext.getItemStateInTargetEnvironment(codename);
+	}).html;
 
-    // replace link item codenames with existing codename or external_id
-    richTextHtml = richTextProcessor().processLinkItemCodenames(richTextHtml, (codename) => {
-        return data.importContext.getItemStateInTargetEnvironment(codename);
-    }).html;
+	// replace link item codenames with existing codename or external_id
+	richTextHtml = richTextProcessor().processLinkItemCodenames(richTextHtml, (codename) => {
+		return data.importContext.getItemStateInTargetEnvironment(codename);
+	}).html;
 
-    // replace asset codenames with existing codename or external_id
-    richTextHtml = richTextProcessor().processAssetCodenames(richTextHtml, (codename) => {
-        return data.importContext.getAssetStateInTargetEnvironment(codename);
-    }).html;
+	// replace asset codenames with existing codename or external_id
+	richTextHtml = richTextProcessor().processAssetCodenames(richTextHtml, (codename) => {
+		return data.importContext.getAssetStateInTargetEnvironment(codename);
+	}).html;
 
-    // replace link asset codenames with existing codename or external_id
-    richTextHtml = richTextProcessor().processLinkAssetCodenames(richTextHtml, (codename) => {
-        return data.importContext.getAssetStateInTargetEnvironment(codename);
-    }).html;
+	// replace link asset codenames with existing codename or external_id
+	richTextHtml = richTextProcessor().processLinkAssetCodenames(richTextHtml, (codename) => {
+		return data.importContext.getAssetStateInTargetEnvironment(codename);
+	}).html;
 
-    return richTextHtml;
+	return richTextHtml;
 }

package/lib/zip/zip-manager.ts

@@ -1,35 +1,36 @@
-import type { Buffer as BufferProxy } from 'buffer';
-import JSZip from 'jszip';
-import type { Logger, MigrationData } from '../core/index.js';
-import { getDefaultLogger } from '../core/index.js';
-import { zipPackager } from './zip-packager.js';
-import { zipTransformer } from './zip-transformer.js';
-import type { FileBinaryData } from './zip.models.js';
+import type { Buffer as BufferProxy } from "buffer";
+import JSZip from "jszip";
+import { getDefaultLogger } from "../core/logs/loggers.js";
+import type { Logger } from "../core/models/log.models.js";
+import type { MigrationData } from "../core/models/migration.models.js";
+import type { FileBinaryData } from "./zip.models.js";
+import { zipPackager } from "./zip-packager.js";
+import { zipTransformer } from "./zip-transformer.js";
 
 export function zipManager(logger?: Logger) {
-    const loggerToUse = logger ?? getDefaultLogger();
+	const loggerToUse = logger ?? getDefaultLogger();
 
-    const createZipAsync = async (migrationData: MigrationData): Promise<FileBinaryData> => {
-        loggerToUse.log({
-            type: 'info',
-            message: `Creating zip package`
-        });
+	const createZipAsync = async (migrationData: MigrationData): Promise<FileBinaryData> => {
+		loggerToUse.log({
+			type: "info",
+			message: `Creating zip package`,
+		});
 
-        return await zipTransformer(zipPackager(new JSZip()), loggerToUse).transformAsync(migrationData);
-    };
+		return await zipTransformer(zipPackager(new JSZip()), loggerToUse).transformAsync(migrationData);
+	};
 
-    const parseZipAsync = async (zipFile: BufferProxy): Promise<MigrationData> => {
-        loggerToUse.log({
-            type: 'info',
-            message: `Parsing zip file`
-        });
+	const parseZipAsync = async (zipFile: BufferProxy): Promise<MigrationData> => {
+		loggerToUse.log({
+			type: "info",
+			message: `Parsing zip file`,
+		});
 
-        const zipPackage = zipPackager(await JSZip.loadAsync(zipFile, {}));
-        return await zipTransformer(zipPackage, loggerToUse).parseAsync();
-    };
+		const zipPackage = zipPackager(await JSZip.loadAsync(zipFile, {}));
+		return await zipTransformer(zipPackage, loggerToUse).parseAsync();
+	};
 
-    return {
-        createZipAsync,
-        parseZipAsync
-    };
+	return {
+		createZipAsync,
+		parseZipAsync,
+	};
 }

package/lib/zip/zip-packager.ts

@@ -1,85 +1,87 @@
-import { Buffer as BufferProxy } from 'buffer';
-import chalk from 'chalk';
-import type JSZip from 'jszip';
-import { match } from 'ts-pattern';
-import type { Logger } from '../core/index.js';
-import { exitProgram, formatBytes, getCurrentEnvironment, getDefaultLogger } from '../core/index.js';
-import type { FileBinaryData, ZipCompressionLevel, ZipPackager } from './zip.models.js';
+import { Buffer as BufferProxy } from "buffer";
+import chalk from "chalk";
+import type JSZip from "jszip";
+import { match } from "ts-pattern";
+import { getDefaultLogger } from "../core/logs/loggers.js";
+import { MigrationToolkitError } from "../core/models/error.models.js";
+import type { Logger } from "../core/models/log.models.js";
+import { exitProgram, formatBytes, getCurrentEnvironment } from "../core/utils/global.utils.js";
+import type { FileBinaryData, ZipCompressionLevel, ZipPackager } from "./zip.models.js";
 
-type ZipOutputType = 'nodebuffer' | 'blob';
+type ZipOutputType = "nodebuffer" | "blob";
 
 export function zipPackager(jsZip: JSZip): ZipPackager {
-    const getZipOutputType = (): 'nodebuffer' | 'blob' => {
-        return match(getCurrentEnvironment())
-            .returnType<ZipOutputType>()
-            .with('browser', () => 'blob')
-            .with('node', () => 'nodebuffer')
-            .exhaustive();
-    };
+	const getZipOutputType = (): "nodebuffer" | "blob" => {
+		return match(getCurrentEnvironment())
+			.returnType<ZipOutputType>()
+			.with("browser", () => "blob")
+			.with("node", () => "nodebuffer")
+			.exhaustive();
+	};
 
-    const getZipSizeInBytes = (zipData: FileBinaryData): number => {
-        return match(zipData)
-            .when(
-                (data) => data instanceof Blob,
-                (data) => data.size
-            )
-            .when(
-                (data) => data instanceof BufferProxy,
-                (data) => data.byteLength
-            )
-            .otherwise(() => {
-                exitProgram({
-                    message: `Unrecognized zip data type '${typeof zipData}'`
-                });
-            });
-    };
+	const getZipSizeInBytes = (zipData: FileBinaryData): number => {
+		return match(zipData)
+			.when(
+				(data) => data instanceof Blob,
+				(data) => data.size,
+			)
+			.when(
+				(data) => data instanceof BufferProxy,
+				(data) => data.byteLength,
+			)
+			.otherwise(() => {
+				exitProgram({
+					message: `Unrecognized zip data type '${typeof zipData}'`,
+				});
+			});
+	};
 
-    return {
-        addFile(filePath: string, data: string | FileBinaryData): JSZip {
-            return jsZip.file(filePath, data);
-        },
-        addFolder(name: string): ZipPackager {
-            const folder = jsZip.folder(name);
+	return {
+		addFile(filePath: string, data: string | FileBinaryData): JSZip {
+			return jsZip.file(filePath, data);
+		},
+		addFolder(name: string): ZipPackager {
+			const folder = jsZip.folder(name);
 
-            if (!folder) {
-                throw Error(`Failed to add folder '${name}'`);
-            }
+			if (!folder) {
+				throw new MigrationToolkitError("invalidFolder", `Failed to add folder '${name}'`);
+			}
 
-            return zipPackager(folder);
-        },
-        async generateZipAsync(config: { logger?: Logger; compressionLevel?: ZipCompressionLevel }): Promise<FileBinaryData> {
-            const logger = config.logger ?? getDefaultLogger();
-            const zipOutputType = getZipOutputType();
-            const compressionLevel: ZipCompressionLevel = config.compressionLevel ?? 9;
+			return zipPackager(folder);
+		},
+		async generateZipAsync(config: { logger?: Logger; compressionLevel?: ZipCompressionLevel }): Promise<FileBinaryData> {
+			const logger = config.logger ?? getDefaultLogger();
+			const zipOutputType = getZipOutputType();
+			const compressionLevel: ZipCompressionLevel = config.compressionLevel ?? 9;
 
-            logger.log({
-                type: 'info',
-                message: `Creating zip file using '${chalk.yellow(zipOutputType)}' with compression level '${chalk.yellow(
-                    compressionLevel.toString()
-                )}'`
-            });
+			logger.log({
+				type: "info",
+				message: `Creating zip file using '${chalk.yellow(zipOutputType)}' with compression level '${chalk.yellow(
+					compressionLevel.toString(),
+				)}'`,
+			});
 
-            const result = await jsZip.generateAsync({
-                type: zipOutputType,
-                compression: 'DEFLATE',
-                compressionOptions: {
-                    level: compressionLevel
-                },
-                streamFiles: true
-            });
+			const result = await jsZip.generateAsync({
+				type: zipOutputType,
+				compression: "DEFLATE",
+				compressionOptions: {
+					level: compressionLevel,
+				},
+				streamFiles: true,
+			});
 
-            logger.log({
-                type: 'info',
-                message: `Zip successfully generated (${chalk.yellow(formatBytes(getZipSizeInBytes(result)))})`
-            });
+			logger.log({
+				type: "info",
+				message: `Zip successfully generated (${chalk.yellow(formatBytes(getZipSizeInBytes(result)))})`,
+			});
 
-            return result;
-        },
-        async getBinaryDataAsync(filePath: string): Promise<FileBinaryData | undefined> {
-            return await jsZip.file(filePath)?.async(getZipOutputType());
-        },
-        async getFileContentAsync(filePath: string): Promise<string | undefined> {
-            return await jsZip.file(filePath)?.async('string');
-        }
-    };
+			return result;
+		},
+		async getBinaryDataAsync(filePath: string): Promise<FileBinaryData | undefined> {
+			return await jsZip.file(filePath)?.async(getZipOutputType());
+		},
+		async getFileContentAsync(filePath: string): Promise<string | undefined> {
+			return await jsZip.file(filePath)?.async("string");
+		},
+	};
 }