@kontent-ai/migration-toolkit 2.2.1 → 2.3.0

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

@@ -1,23 +1,22 @@
 import {
-    WorkflowModels,
-    LanguageVariantModels,
-    ContentItemModels,
     AssetModels,
     CollectionModels,
-    LanguageModels
+    ContentItemModels,
+    LanguageModels,
+    LanguageVariantModels,
+    WorkflowModels
 } from '@kontent-ai/management-sdk';
 import chalk from 'chalk';
 import {
-    processItemsAsync,
-    runMapiRequestAsync,
-    is404Error,
-    ItemStateInSourceEnvironmentById,
     AssetStateInSourceEnvironmentById,
+    findRequired,
     FlattenedContentType,
-    isNotUndefined,
-    managementClientUtils,
+    is404Error,
+    ItemStateInSourceEnvironmentById,
     LogSpinnerData,
-    findRequired,
+    managementClientUtils,
+    processItemsAsync,
+    runMapiRequestAsync,
     workflowHelper
 } from '../../core/index.js';
 import { itemsExtractionProcessor } from '../../translation/index.js';
@@ -25,10 +24,10 @@ import {
     DefaultExportContextConfig,
     ExportContext,
     ExportContextEnvironmentData,
-    SourceExportItem,
     ExportItem,
+    ExportItemVersion,
     GetFlattenedElementByIds,
-    ExportItemVersion
+    SourceExportItem
 } from '../export.models.js';
 import { throwErrorForItemRequest } from '../utils/export.utils.js';
 
@@ -173,11 +172,11 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
         readonly contentItem: Readonly<ContentItemModels.ContentItem>;
         readonly languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant>;
     }): {
-        collection: Readonly<CollectionModels.Collection>;
-        language: Readonly<LanguageModels.LanguageModel>;
-        workflow: Readonly<WorkflowModels.Workflow>;
-        contentType: Readonly<FlattenedContentType>;
-        workflowStepCodename: string;
+        readonly collection: Readonly<CollectionModels.Collection>;
+        readonly language: Readonly<LanguageModels.LanguageModel>;
+        readonly workflow: Readonly<WorkflowModels.Workflow>;
+        readonly contentType: Readonly<FlattenedContentType>;
+        readonly workflowStepCodename: string;
     } => {
         const collection = findRequired(
             environmentData.collections,
@@ -234,49 +233,53 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
             message: `Preparing '${chalk.yellow(config.exportItems.length.toString())}' items for export`
         });
 
-        return await processItemsAsync<SourceExportItem, ExportItem>({
-            logger: config.logger,
-            action: 'Preparing content items & language variants',
-            parallelLimit: 1,
-            itemInfo: (input) => {
-                return {
-                    title: `${input.itemCodename} (${input.languageCodename})`,
-                    itemType: 'exportItem'
-                };
-            },
-            items: exportItems,
-            processAsync: async (requestItem, logSpinner) => {
-                const contentItem = await getContentItemAsync(requestItem, logSpinner);
-                const versions = await getExportItemVersionsAsync(requestItem, contentItem, logSpinner);
-
-                // get shared attributes from any version
-                const anyVersion = versions[0];
-                if (!anyVersion) {
-                    throwErrorForItemRequest(requestItem, `Expected at least 1 version of the content item`);
-                }
+        return (
+            await processItemsAsync<SourceExportItem, ExportItem>({
+                logger: config.logger,
+                action: 'Preparing content items & language variants',
+                parallelLimit: 1,
+                itemInfo: (input) => {
+                    return {
+                        title: `${input.itemCodename} (${input.languageCodename})`,
+                        itemType: 'exportItem'
+                    };
+                },
+                items: exportItems,
+                processAsync: async (requestItem, logSpinner) => {
+                    const contentItem = await getContentItemAsync(requestItem, logSpinner);
+                    const versions = await getExportItemVersionsAsync(requestItem, contentItem, logSpinner);
+
+                    // get shared attributes from any version
+                    const anyVersion = versions[0];
+                    if (!anyVersion) {
+                        throwErrorForItemRequest(requestItem, `Expected at least 1 version of the content item`);
+                    }
 
-                const { collection, contentType, language, workflow } = validateExportItem({
-                    sourceItem: requestItem,
-                    contentItem: contentItem,
-                    languageVariant: anyVersion.languageVariant
-                });
+                    const { collection, contentType, language, workflow } = validateExportItem({
+                        sourceItem: requestItem,
+                        contentItem: contentItem,
+                        languageVariant: anyVersion.languageVariant
+                    });
 
-                return {
-                    contentItem,
-                    versions,
-                    contentType,
-                    requestItem,
-                    workflow,
-                    collection,
-                    language
-                };
-            }
-        });
+                    return {
+                        contentItem,
+                        versions,
+                        contentType,
+                        requestItem,
+                        workflow,
+                        collection,
+                        language
+                    };
+                }
+            })
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getContentItemsByIdsAsync = async (itemIds: ReadonlySet<string>): Promise<readonly Readonly<ContentItemModels.ContentItem>[]> => {
         return (
-            await processItemsAsync<string, Readonly<ContentItemModels.ContentItem> | undefined>({
+            await processItemsAsync<string, Readonly<ContentItemModels.ContentItem>>({
                 logger: config.logger,
                 action: 'Fetching content items',
                 parallelLimit: 1,
@@ -302,16 +305,18 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
                             throw error;
                         }
 
-                        return undefined;
+                        return '404';
                     }
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getAssetsByIdsAsync = async (itemIds: ReadonlySet<string>): Promise<readonly Readonly<AssetModels.Asset>[]> => {
         return (
-            await processItemsAsync<string, Readonly<AssetModels.Asset> | undefined>({
+            await processItemsAsync<string, Readonly<AssetModels.Asset>>({
                 logger: config.logger,
                 action: 'Fetching assets',
                 parallelLimit: 1,
@@ -337,11 +342,13 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
                             throw error;
                         }
 
-                        return undefined;
+                        return '404';
                     }
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getItemStatesAsync = async (itemIds: ReadonlySet<string>): Promise<readonly ItemStateInSourceEnvironmentById[]> => {

package/lib/export/export-manager.ts

@@ -45,8 +45,8 @@ export function exportManager(config: ExportConfig) {
                     codename: exportItem.workflow.codename
                 }
             },
-            versions: exportItem.versions.map((version) => {
-                return <MigrationItemVersion>{
+            versions: exportItem.versions.map<MigrationItemVersion>((version) => {
+                return {
                     elements: getMigrationElements(context, exportItem.contentType, version.languageVariant.elements),
                     schedule: {
                         publish_time: version.languageVariant.schedule.publishTime ?? undefined,
@@ -124,10 +124,10 @@ export function exportManager(config: ExportConfig) {
     };
 
     const getMigrationElementToStore = (data: {
-        context: ExportContext;
-        contentType: FlattenedContentType;
-        typeElement: FlattenedContentTypeElement;
-        exportElement: ElementModels.ContentItemElement;
+        readonly context: ExportContext;
+        readonly contentType: FlattenedContentType;
+        readonly typeElement: FlattenedContentTypeElement;
+        readonly exportElement: ElementModels.ContentItemElement;
     }): MigrationElementTransformData => {
         try {
             return exportTransforms[data.typeElement.type]({
@@ -175,60 +175,62 @@ export function exportManager(config: ExportConfig) {
             message: `Preparing to download '${chalk.yellow(assets.length.toString())}' assets`
         });
 
-        return await processItemsAsync<Readonly<AssetModels.Asset>, MigrationAsset>({
-            action: 'Downloading assets',
-            logger: logger,
-            parallelLimit: 5,
-            itemInfo: (input) => {
-                return {
-                    title: input.codename,
-                    itemType: 'asset'
-                };
-            },
-            items: assets,
-            processAsync: async (asset, logSpinner) => {
-                const assetCollection: Readonly<CollectionModels.Collection> | undefined = context.environmentData.collections.find(
-                    (m) => m.id === asset.collection?.reference?.id
-                );
-                const assetFolder: Readonly<AssetFolderModels.AssetFolder> | undefined = context.environmentData.assetFolders.find(
-                    (m) => m.id === asset.folder?.id
-                );
+        return (
+            await processItemsAsync<Readonly<AssetModels.Asset>, MigrationAsset>({
+                action: 'Downloading assets',
+                logger: logger,
+                parallelLimit: 5,
+                itemInfo: (input) => {
+                    return {
+                        title: input.codename,
+                        itemType: 'asset'
+                    };
+                },
+                items: assets,
+                processAsync: async (asset, logSpinner) => {
+                    const assetCollection: Readonly<CollectionModels.Collection> | undefined = context.environmentData.collections.find(
+                        (m) => m.id === asset.collection?.reference?.id
+                    );
+                    const assetFolder: Readonly<AssetFolderModels.AssetFolder> | undefined = context.environmentData.assetFolders.find(
+                        (m) => m.id === asset.folder?.id
+                    );
 
-                logSpinner({
-                    type: 'download',
-                    message: `${asset.url}`
-                });
+                    logSpinner({
+                        type: 'download',
+                        message: `${asset.url}`
+                    });
 
-                const binaryData = await getBinaryDataFromUrlAsync(asset.url);
+                    const migrationAsset: MigrationAsset = {
+                        filename: asset.fileName,
+                        title: asset.title ?? '',
+                        codename: asset.codename,
+                        binary_data: (await getBinaryDataFromUrlAsync(asset.url)).data,
+                        collection: assetCollection ? { codename: assetCollection.codename } : undefined,
+                        folder: assetFolder ? { codename: assetFolder.codename } : undefined,
+                        descriptions: asset.descriptions.map((description) => {
+                            const language = findRequired(
+                                context.environmentData.languages,
+                                (language) => language.id === description.language.id,
+                                `Could not find language with id '${chalk.red(description.language.id)}' requested by asset '${chalk.red(
+                                    asset.codename
+                                )}'`
+                            );
 
-                const migrationAsset: MigrationAsset = {
-                    filename: asset.fileName,
-                    title: asset.title ?? '',
-                    codename: asset.codename,
-                    binary_data: binaryData.data,
-                    collection: assetCollection ? { codename: assetCollection.codename } : undefined,
-                    folder: assetFolder ? { codename: assetFolder.codename } : undefined,
-                    descriptions: asset.descriptions.map((description) => {
-                        const language = findRequired(
-                            context.environmentData.languages,
-                            (language) => language.id === description.language.id,
-                            `Could not find language with id '${chalk.red(description.language.id)}' requested by asset '${chalk.red(
-                                asset.codename
-                            )}'`
-                        );
+                            return {
+                                description: description.description ?? undefined,
+                                language: {
+                                    codename: language.codename
+                                }
+                            };
+                        })
+                    };
 
-                        return {
-                            description: description.description ?? undefined,
-                            language: {
-                                codename: language.codename
-                            }
-                        };
-                    })
-                };
-
-                return migrationAsset;
-            }
-        });
+                    return migrationAsset;
+                }
+            })
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     return {

package/lib/file/file-manager.ts

@@ -1,13 +1,14 @@
+import { Buffer as BufferProxy } from 'buffer';
 import chalk from 'chalk';
-import { Logger } from '../core/index.js';
 import { promises } from 'fs';
+import { Logger } from '../core/index.js';
 
 export function fileManager(logger: Logger) {
     const getFilePath = (filename: string): string => {
         return `./${filename}`;
     };
 
-    const loadFileAsync = async (filename: string): Promise<Buffer> => {
+    const loadFileAsync = async (filename: string): Promise<BufferProxy> => {
         const filePath = getFilePath(filename);
 
         logger.log({
@@ -20,7 +21,7 @@ export function fileManager(logger: Logger) {
         return file;
     };
 
-    const writeFileAsync = async (fileNameWithoutExtension: string, content: string | Buffer): Promise<void> => {
+    const writeFileAsync = async (fileNameWithoutExtension: string, content: string | BufferProxy): Promise<void> => {
         const filePath = getFilePath(fileNameWithoutExtension);
 
         logger.log({

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

@@ -1,4 +1,6 @@
 import { AssetModels, ContentItemModels, LanguageVariantModels } from '@kontent-ai/management-sdk';
+import chalk from 'chalk';
+import { match } from 'ts-pattern';
 import {
     AssetStateInTargetEnvironmentByCodename,
     ItemStateInTargetEnvironmentByCodename,
@@ -12,16 +14,13 @@ import {
     WorkflowStep,
     findRequired,
     is404Error,
-    isNotUndefined,
     managementClientUtils,
     processItemsAsync,
     runMapiRequestAsync,
     workflowHelper as workflowHelperInit
 } from '../../core/index.js';
-import { GetFlattenedElementByCodenames, ImportContext, ImportContextConfig, ImportContextEnvironmentData } from '../import.models.js';
 import { ExtractItemByCodename, itemsExtractionProcessor } from '../../translation/index.js';
-import chalk from 'chalk';
-import { match } from 'ts-pattern';
+import { GetFlattenedElementByCodenames, ImportContext, ImportContextConfig, ImportContextEnvironmentData } from '../import.models.js';
 
 interface LanguageVariantWrapper {
     readonly draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
@@ -150,7 +149,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
         migrationItems: readonly MigrationItem[]
     ): Promise<readonly LanguageVariantWrapper[]> => {
         return (
-            await processItemsAsync<MigrationItem, LanguageVariantWrapper | undefined>({
+            await processItemsAsync<MigrationItem, LanguageVariantWrapper>({
                 action: 'Fetching language variants',
                 logger: config.logger,
                 parallelLimit: 1,
@@ -166,7 +165,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
 
                     if (!latestLanguageVariant) {
                         // there is neither published or draft version as latest version does not exist at all
-                        return undefined;
+                        return '404';
                     }
 
                     if (workflowHelper.isPublishedStepById(latestLanguageVariant.workflow.stepIdentifier.id ?? '')) {
@@ -186,14 +185,16 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                     };
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getContentItemsByCodenamesAsync = async (
         itemCodenames: ReadonlySet<string>
     ): Promise<readonly ContentItemModels.ContentItem[]> => {
         return (
-            await processItemsAsync<string, Readonly<ContentItemModels.ContentItem> | undefined>({
+            await processItemsAsync<string, Readonly<ContentItemModels.ContentItem>>({
                 action: 'Fetching content items',
                 logger: config.logger,
                 parallelLimit: 1,
@@ -219,16 +220,18 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                             throw error;
                         }
 
-                        return undefined;
+                        return '404';
                     }
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getAssetsByCodenamesAsync = async (assetCodenames: ReadonlySet<string>): Promise<readonly AssetModels.Asset[]> => {
         return (
-            await processItemsAsync<string, Readonly<AssetModels.Asset> | undefined>({
+            await processItemsAsync<string, Readonly<AssetModels.Asset>>({
                 action: 'Fetching assets',
                 logger: config.logger,
                 parallelLimit: 1,
@@ -254,11 +257,13 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                             throw error;
                         }
 
-                        return undefined;
+                        return '404';
                     }
                 }
             })
-        ).filter(isNotUndefined);
+        )
+            .filter((m) => m.state === 'valid')
+            .map((m) => m.outputItem);
     };
 
     const getVariantState = (languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant>): LanguageVariantStateData => {