@kontent-ai/migration-toolkit 1.3.0 → 1.5.0

package/lib/node/cli/app.ts

@@ -7,25 +7,24 @@ import { importActionAsync } from './actions/import-action.js';
 import { migrateActionAsync } from './actions/migrate-action.js';
 import { argumentsFetcherAsync } from './args/args-fetcher.js';
 import { cliArgs } from './commands.js';
+import { match } from 'ts-pattern';
 
-// This enabled --help with all commands, options & samples
+// Need to register --help commands
 cliArgs.registerCommands();
 
 const run = async () => {
     const argsFetcher = await argumentsFetcherAsync();
     const action = argsFetcher.getCliAction();
 
-    if (action === 'export') {
-        return await exportActionAsync(argsFetcher);
-    } else if (action === 'import') {
-        return await importActionAsync(argsFetcher);
-    } else if (action === 'migrate') {
-        return await migrateActionAsync(argsFetcher);
-    }
-
-    exitProgram({
-        message: `Invalid action '${chalk.red(action)}'`
-    });
+    return await match(action)
+        .with('export', async () => await exportActionAsync(argsFetcher))
+        .with('import', async () => await importActionAsync(argsFetcher))
+        .with('migrate', async () => await migrateActionAsync(argsFetcher))
+        .otherwise(() =>
+            exitProgram({
+                message: `Invalid action '${chalk.red(action)}'`
+            })
+        );
 };
 
 run().catch((err) => {

package/lib/node/cli/args/args-fetcher.ts

@@ -1,8 +1,9 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import chalk from 'chalk';
-import { CliAction, exitProgram } from '../../../core/index.js';
+import { CliAction, exitProgram, LiteralUnion } from '../../../core/index.js';
 import { CliArgumentsFetcher } from '../cli.models.js';
+import { match } from 'ts-pattern';
 
 type ArgvResult = {
     [x: string]: unknown;
@@ -20,19 +21,16 @@ export async function argumentsFetcherAsync(): Promise<CliArgumentsFetcher> {
 
     return {
         getCliAction(): CliAction {
-            const command = resolvedArgv._?.[0]?.toString()?.toLowerCase();
-
-            if (command === <CliAction>'export') {
-                return 'export';
-            }
-            if (command === <CliAction>'import') {
-                return 'import';
-            }
-            if (command === <CliAction>'migrate') {
-                return 'migrate';
-            }
-
-            throw Error(`Unsupported command '${chalk.yellow(command)}'`);
+            const command = resolvedArgv._?.[0]?.toString()?.toLowerCase() as LiteralUnion<CliAction>;
+
+            return match(command)
+                .returnType<CliAction>()
+                .with('export', () => 'export')
+                .with('import', () => 'import')
+                .with('migrate', () => 'migrate')
+                .otherwise(() => {
+                    throw Error(`Unsupported command '${chalk.yellow(command)}'`);
+                });
         },
         getOptionalArgumentValue(argName: string): string | undefined {
             return resolvedArgv[argName]?.toString();

package/lib/toolkit/migrate.ts

@@ -17,14 +17,12 @@ export interface MigrationSource extends ManagementClientConfig {
     readonly items: readonly SourceExportItem[];
 }
 
-export interface MigrationTarget extends ManagementClientConfig {}
-
 export interface MigrationConfig {
     readonly retryStrategy?: IRetryStrategyOptions;
     readonly externalIdGenerator?: ExternalIdGenerator;
     readonly logger?: Logger;
     readonly sourceEnvironment: MigrationSource;
-    readonly targetEnvironment: MigrationTarget;
+    readonly targetEnvironment: ManagementClientConfig;
 }
 
 export interface MigrationResult {

package/lib/translation/extraction/items-extraction.processor.ts

@@ -9,6 +9,7 @@ import {
 import { GetFlattenedElementByCodenames } from '../../import/index.js';
 import { ElementModels } from '@kontent-ai/management-sdk';
 import { GetFlattenedElementByIds } from 'lib/export/export.models.js';
+import { match, P } from 'ts-pattern';
 
 export interface ExtractItemById {
     readonly elements: Readonly<ElementModels.ContentItemElement>[];
@@ -40,45 +41,49 @@ export function itemsExtractionProcessor() {
                 return item.elements.reduce<ReferencedDataInLanguageVariantsLocal>((childExtractedIds, itemElement) => {
                     const typeElement = getElement(item.contentTypeId, itemElement.element.id ?? '');
 
-                    if (typeElement.type === 'rich_text') {
-                        const rteValue = itemElement.value?.toString();
-
-                        // extract referenced items
-                        richTextProcessor()
-                            .processDataIds(rteValue ?? '')
-                            .ids.forEach((id) => extractedIds.itemIds.add(id));
-
-                        richTextProcessor()
-                            .processLinkItemIds(rteValue ?? '')
-                            .ids.forEach((id) => extractedIds.itemIds.add(id));
-
-                        // extract referenced assets
-                        richTextProcessor()
-                            .processAssetIds(rteValue ?? '')
-                            .ids.forEach((id) => extractedIds.assetIds.add(id));
-
-                        // recursively extract data from components as well because they may reference additional assets & content items
-                        const extractedComponents = extractReferencedDataFromExtractItems(
-                            itemElement.components.map((component) => {
-                                return {
-                                    contentTypeId: component.type.id ?? '',
-                                    elements: component.elements
-                                };
-                            }),
-                            getElement
-                        );
-
-                        extractedComponents.itemIds.forEach((id) => extractedIds.itemIds.add(id));
-                        extractedComponents.assetIds.forEach((id) => extractedIds.assetIds.add(id));
-                    } else if (typeElement.type === 'modular_content' || typeElement.type === 'subpages') {
-                        if (itemElement.value && Array.isArray(itemElement.value)) {
-                            itemElement.value.forEach((value) => (value.id ? extractedIds.itemIds.add(value.id) : {}));
-                        }
-                    } else if (typeElement.type === 'asset') {
-                        if (itemElement.value && Array.isArray(itemElement.value)) {
-                            itemElement.value.forEach((value) => (value.id ? extractedIds.assetIds.add(value.id) : {}));
-                        }
-                    }
+                    match(typeElement.type)
+                        .with('rich_text', () => {
+                            const rteValue = itemElement.value?.toString();
+
+                            // extract referenced items
+                            richTextProcessor()
+                                .processDataIds(rteValue ?? '')
+                                .ids.forEach((id) => extractedIds.itemIds.add(id));
+
+                            richTextProcessor()
+                                .processLinkItemIds(rteValue ?? '')
+                                .ids.forEach((id) => extractedIds.itemIds.add(id));
+
+                            // extract referenced assets
+                            richTextProcessor()
+                                .processAssetIds(rteValue ?? '')
+                                .ids.forEach((id) => extractedIds.assetIds.add(id));
+
+                            // recursively extract data from components as well because they may reference additional assets & content items
+                            const extractedComponents = extractReferencedDataFromExtractItems(
+                                itemElement.components.map((component) => {
+                                    return {
+                                        contentTypeId: component.type.id ?? '',
+                                        elements: component.elements
+                                    };
+                                }),
+                                getElement
+                            );
+
+                            extractedComponents.itemIds.forEach((id) => extractedIds.itemIds.add(id));
+                            extractedComponents.assetIds.forEach((id) => extractedIds.assetIds.add(id));
+                        })
+                        .with(P.union('modular_content', 'subpages'), () => {
+                            if (itemElement.value && Array.isArray(itemElement.value)) {
+                                itemElement.value.forEach((value) => (value.id ? extractedIds.itemIds.add(value.id) : {}));
+                            }
+                        })
+                        .with('asset', () => {
+                            if (itemElement.value && Array.isArray(itemElement.value)) {
+                                itemElement.value.forEach((value) => (value.id ? extractedIds.assetIds.add(value.id) : {}));
+                            }
+                        })
+                        .otherwise(() => {});
 
                     return childExtractedIds;
                 }, extractedIds);
@@ -102,60 +107,55 @@ export function itemsExtractionProcessor() {
                     (childExtractedCodenames, [elementCodename, element]) => {
                         const flattenedElement = getElement(item.contentTypeCodename, elementCodename, element.type);
 
-                        if (flattenedElement.type === 'rich_text') {
-                            const richTextElementValue = element as MigrationElementModels.RichTextElement;
-
-                            if (!richTextElementValue.value) {
-                                return childExtractedCodenames;
-                            }
-
-                            const richTextHtml = richTextElementValue.value?.value ?? '';
-
-                            // items
-                            richTextProcessor()
-                                .processItemCodenames(richTextHtml)
-                                .codenames.forEach((codename) => childExtractedCodenames.itemCodenames.add(codename));
-
-                            richTextProcessor()
-                                .processLinkItemCodenames(richTextHtml)
-                                .codenames.forEach((codename) => childExtractedCodenames.itemCodenames.add(codename));
-
-                            // assets
-                            richTextProcessor()
-                                .processAssetCodenames(richTextHtml)
-                                .codenames.forEach((codename) => childExtractedCodenames.assetCodenames.add(codename));
-
-                            // recursively extract data from components as well because they may reference additional assets & content items
-                            const extractedComponents = extractReferencedItemsFromMigrationItems(
-                                richTextElementValue.value.components.map((component) => {
-                                    const extractionItem: ExtractItemByCodename = {
-                                        contentTypeCodename: component.system.type.codename,
-                                        elements: component.elements
-                                    };
-
-                                    return extractionItem;
-                                }),
-                                getElement
-                            );
-
-                            extractedComponents.itemCodenames.forEach((codename) =>
-                                childExtractedCodenames.itemCodenames.add(codename)
-                            );
-                            extractedComponents.assetCodenames.forEach((codename) =>
-                                childExtractedCodenames.assetCodenames.add(codename)
-                            );
-                        } else if (
-                            flattenedElement.type === 'modular_content' ||
-                            flattenedElement.type === 'subpages'
-                        ) {
-                            parseAsMigrationReferencesArray(element.value)
-                                .map((m) => m.codename)
-                                .forEach((codename) => childExtractedCodenames.itemCodenames.add(codename));
-                        } else if (flattenedElement.type === 'asset') {
-                            parseAsMigrationReferencesArray(element.value)
-                                .map((m) => m.codename)
-                                .forEach((codename) => childExtractedCodenames.assetCodenames.add(codename));
-                        }
+                        match(flattenedElement.type)
+                            .with('rich_text', () => {
+                                const richTextElementValue = element as MigrationElementModels.RichTextElement;
+                                const richTextHtml = richTextElementValue.value?.value ?? '';
+
+                                // items
+                                richTextProcessor()
+                                    .processItemCodenames(richTextHtml)
+                                    .codenames.forEach((codename) => childExtractedCodenames.itemCodenames.add(codename));
+
+                                richTextProcessor()
+                                    .processLinkItemCodenames(richTextHtml)
+                                    .codenames.forEach((codename) => childExtractedCodenames.itemCodenames.add(codename));
+
+                                // assets
+                                richTextProcessor()
+                                    .processAssetCodenames(richTextHtml)
+                                    .codenames.forEach((codename) => childExtractedCodenames.assetCodenames.add(codename));
+
+                                // recursively extract data from components as well because they may reference additional assets & content items
+                                const extractedComponents = extractReferencedItemsFromMigrationItems(
+                                    (richTextElementValue.value?.components ?? []).map((component) => {
+                                        const extractionItem: ExtractItemByCodename = {
+                                            contentTypeCodename: component.system.type.codename,
+                                            elements: component.elements
+                                        };
+
+                                        return extractionItem;
+                                    }),
+                                    getElement
+                                );
+
+                                extractedComponents.itemCodenames.forEach((codename) =>
+                                    childExtractedCodenames.itemCodenames.add(codename)
+                                );
+                                extractedComponents.assetCodenames.forEach((codename) =>
+                                    childExtractedCodenames.assetCodenames.add(codename)
+                                );
+                            })
+                            .with(P.union('modular_content', 'subpages'), () => {
+                                parseAsMigrationReferencesArray(element.value)
+                                    .map((m) => m.codename)
+                                    .forEach((codename) => childExtractedCodenames.itemCodenames.add(codename));
+                            })
+                            .with('asset', () => {
+                                parseAsMigrationReferencesArray(element.value)
+                                    .map((m) => m.codename)
+                                    .forEach((codename) => childExtractedCodenames.assetCodenames.add(codename));
+                            });
 
                         return childExtractedCodenames;
                     },

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

@@ -181,7 +181,7 @@ function findTaxonomy(termId: string, taxonomy: Readonly<TaxonomyModels.Taxonomy
     }
 
     if (taxonomy.terms) {
-        const foundTerm = taxonomy.terms.find((term) => findTaxonomy(term.id, term));
+        const foundTerm = taxonomy.terms.find((term) => findTaxonomy(termId, term));
 
         if (foundTerm) {
             return foundTerm;

package/lib/zip/zip-packager.ts

@@ -2,33 +2,34 @@ import JSZip from 'jszip';
 import chalk from 'chalk';
 import { Logger, formatBytes, getCurrentEnvironment, exitProgram, getDefaultLogger } from '../core/index.js';
 import { FileBinaryData, ZipCompressionLevel, ZipPackager } from './zip.models.js';
+import { match } from 'ts-pattern';
+
+type ZipOutputType = 'nodebuffer' | 'blob';
 
 export function zipPackager(jsZip: JSZip): ZipPackager {
     const getZipOutputType = (): 'nodebuffer' | 'blob' => {
-        const currentEnv = getCurrentEnvironment();
-
-        if (currentEnv === 'browser') {
-            return 'blob';
-        }
-        if (currentEnv === 'node') {
-            return 'nodebuffer';
-        }
-
-        exitProgram({
-            message: `Unsupported context`
-        });
+        return match(getCurrentEnvironment())
+            .returnType<ZipOutputType>()
+            .with('browser', () => 'blob')
+            .with('node', () => 'nodebuffer')
+            .exhaustive();
     };
 
     const getZipSizeInBytes = (zipData: FileBinaryData): number => {
-        if (zipData instanceof Blob) {
-            return zipData.size;
-        } else if (zipData instanceof Buffer) {
-            return zipData.byteLength;
-        }
-
-        exitProgram({
-            message: `Unrecognized zip data type '${typeof zipData}'`
-        });
+        return match(zipData)
+            .when(
+                (data) => data instanceof Blob,
+                (data) => data.size
+            )
+            .when(
+                (data) => data instanceof Buffer,
+                (data) => data.byteLength
+            )
+            .otherwise(() => {
+                exitProgram({
+                    message: `Unrecognized zip data type '${typeof zipData}'`
+                });
+            });
     };
 
     return {
@@ -44,19 +45,16 @@ export function zipPackager(jsZip: JSZip): ZipPackager {
 
             return zipPackager(folder);
         },
-        async generateZipAsync(config: {
-            logger?: Logger;
-            compressionLevel?: ZipCompressionLevel;
-        }): Promise<FileBinaryData> {
+        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())}'`
+                message: `Creating zip file using '${chalk.yellow(zipOutputType)}' with compression level '${chalk.yellow(
+                    compressionLevel.toString()
+                )}'`
             });
 
             const result = await jsZip.generateAsync({

package/lib/zip/zip-transformer.ts

@@ -48,7 +48,8 @@ export function zipTransformer(zip: ZipPackager, logger?: Logger) {
                 title: asset.title,
                 codename: asset.codename,
                 collection: asset.collection,
-                descriptions: asset.descriptions
+                descriptions: asset.descriptions,
+                folder: asset.folder
             });
 
             if (asset.binaryData) {
@@ -91,6 +92,7 @@ export function zipTransformer(zip: ZipPackager, logger?: Logger) {
                 collection: assetRecord.collection,
                 title: assetRecord.title,
                 descriptions: assetRecord.descriptions,
+                folder: assetRecord.folder,
                 binaryData: binaryFile
             };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kontent-ai/migration-toolkit",
-    "version": "1.3.0",
+    "version": "1.5.0",
     "description": "This program can be used to import content related data into Kontent.ai from various formats. Additionally, it can also be used to export Kontent.ai data using Delivery API.",
     "preferGlobal": true,
     "private": false,
@@ -52,8 +52,8 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@kontent-ai-consulting/tools-analytics": "0.0.6",
-        "@kontent-ai/management-sdk": "6.5.0",
+        "@kontent-ai-consulting/tools-analytics": "0.0.7",
+        "@kontent-ai/management-sdk": "7.2.0",
         "browser-or-node": "3.0.0",
         "bytes": "3.1.2",
         "chalk": "5.3.0",
@@ -65,24 +65,25 @@
         "yargs": "17.7.2",
         "p-limit": "6.1.0",
         "deep-equal": "2.2.3",
-        "zod": "3.23.8"
+        "zod": "3.23.8",
+        "ts-pattern": "5.3.1"
     },
     "devDependencies": {
-        "@eslint/js": "9.7.0",
+        "@eslint/js": "9.9.0",
         "@types/deep-equal": "1.0.4",
         "@types/browser-or-node": "1.3.2",
         "@types/bytes": "3.1.4",
         "@types/eslint__js": "8.42.3",
-        "@types/node": "20.14.11",
+        "@types/node": "22.3.0",
         "@types/prompts": "2.4.9",
-        "@types/yargs": "17.0.32",
-        "@typescript-eslint/eslint-plugin": "7.16.1",
-        "@typescript-eslint/parser": "7.16.1",
-        "eslint": "8.57.0",
+        "@types/yargs": "17.0.33",
+        "@typescript-eslint/eslint-plugin": "8.1.0",
+        "@typescript-eslint/parser": "8.1.0",
+        "eslint": "9.9.0",
         "standard-version": "9.5.0",
         "tslib": "2.6.3",
-        "tsx": "4.16.2",
-        "typescript": "5.5.3",
-        "typescript-eslint": "7.16.1"
+        "tsx": "4.17.0",
+        "typescript": "5.5.4",
+        "typescript-eslint": "8.1.0"
     }
 }