@kontent-ai/migration-toolkit 1.0.0

package/lib/import/importers/assets-importer.ts

@@ -0,0 +1,239 @@
+import { AssetModels, ManagementClient } from '@kontent-ai/management-sdk';
+import {
+    MigrationAsset,
+    Logger,
+    processItemsAsync,
+    runMapiRequestAsync,
+    MigrationAssetDescription,
+    MigrationReference,
+    geSizeInBytes,
+    isNotUndefined,
+    LogSpinnerData
+} from '../../core/index.js';
+import mime from 'mime';
+import chalk from 'chalk';
+import { ImportContext, ImportResult } from '../import.models.js';
+import { shouldReplaceBinaryFile, shouldUpdateAsset } from '../comparers/asset-comparer.js';
+
+interface AssetToEdit {
+    migrationAsset: MigrationAsset;
+    targetAsset: Readonly<AssetModels.Asset>;
+    replaceBinaryFile: boolean;
+}
+
+export function assetsImporter(data: {
+    readonly logger: Logger;
+    readonly client: Readonly<ManagementClient>;
+    readonly importContext: ImportContext;
+}) {
+    const getAssetsToUpload = (): readonly MigrationAsset[] => {
+        return data.importContext.categorizedImportData.assets.filter((asset) => {
+            return data.importContext.getAssetStateInTargetEnvironment(asset.codename).state === 'doesNotExists';
+        });
+    };
+
+    const getAssetsToEdit = (): readonly AssetToEdit[] => {
+        return data.importContext.categorizedImportData.assets
+            .map<AssetToEdit | undefined>((migrationAsset) => {
+                const assetState = data.importContext.getAssetStateInTargetEnvironment(migrationAsset.codename);
+
+                if (!assetState.asset || assetState.state === 'doesNotExists') {
+                    return undefined;
+                }
+
+                if (
+                    !shouldUpdateAsset({
+                        collections: data.importContext.environmentData.collections,
+                        languages: data.importContext.environmentData.languages,
+                        migrationAsset: migrationAsset,
+                        targetAsset: assetState.asset
+                    })
+                ) {
+                    return undefined;
+                }
+
+                return {
+                    migrationAsset: migrationAsset,
+                    replaceBinaryFile: shouldReplaceBinaryFile({
+                        migrationAsset: migrationAsset,
+                        targetAsset: assetState.asset
+                    }),
+                    targetAsset: assetState.asset
+                };
+            })
+            .filter(isNotUndefined);
+    };
+
+    const editAssets = async (
+        assetsToEdit: readonly AssetToEdit[]
+    ): Promise<readonly Readonly<AssetModels.Asset>[]> => {
+        data.logger.log({
+            type: 'upsert',
+            message: `Upserting '${chalk.yellow(assetsToEdit.length.toString())}' assets`
+        });
+
+        return await processItemsAsync<AssetToEdit, Readonly<AssetModels.Asset>>({
+            action: 'Upserting assets',
+            logger: data.logger,
+            parallelLimit: 1,
+            items: assetsToEdit,
+            itemInfo: (input) => {
+                return {
+                    itemType: 'asset',
+                    title: input.migrationAsset.title
+                };
+            },
+            processAsync: async (assetEditRequest, logSpinner) => {
+                let uploadedBinaryFile: Readonly<AssetModels.AssetFileReference> | undefined;
+
+                if (assetEditRequest.replaceBinaryFile) {
+                    uploadedBinaryFile = await uploadBinaryFileAsync(assetEditRequest.migrationAsset, logSpinner);
+                }
+
+                return await runMapiRequestAsync({
+                    logger: data.logger,
+                    func: async () => {
+                        return (
+                            await data.client
+                                .upsertAsset()
+                                .byAssetCodename(assetEditRequest.migrationAsset.codename)
+                                .withData(() => {
+                                    return {
+                                        title: assetEditRequest.migrationAsset.title,
+                                        descriptions: mapAssetDescriptions(
+                                            assetEditRequest.migrationAsset.descriptions
+                                        ),
+                                        collection: mapAssetCollection(assetEditRequest.migrationAsset.collection),
+                                        file_reference: uploadedBinaryFile ?? undefined
+                                    };
+                                })
+                                .toPromise()
+                        ).data;
+                    },
+                    action: 'upsert',
+                    type: 'asset',
+                    logSpinner: logSpinner,
+                    itemName: `${assetEditRequest.migrationAsset.title ?? assetEditRequest.migrationAsset.filename}`
+                });
+            }
+        });
+    };
+
+    const mapAssetCollection = (
+        migrationCollection: MigrationReference | undefined
+    ): Readonly<AssetModels.IAssetCollectionReferenceObject> | undefined => {
+        return migrationCollection
+            ? {
+                  reference: {
+                      codename: migrationCollection.codename
+                  }
+              }
+            : undefined;
+    };
+
+    const mapAssetDescriptions = (
+        migrationDescription: readonly MigrationAssetDescription[] | undefined
+    ): Readonly<AssetModels.IAssetFileDescription>[] => {
+        return (migrationDescription ?? []).map((m) => {
+            const assetDescription: Readonly<AssetModels.IAssetFileDescription> = {
+                description: m.description ?? '',
+                language: {
+                    codename: m.language.codename
+                }
+            };
+
+            return assetDescription;
+        });
+    };
+
+    const uploadBinaryFileAsync = async (
+        migrationAsset: MigrationAsset,
+        logSpinner: LogSpinnerData
+    ): Promise<Readonly<AssetModels.AssetFileReference>> => {
+        return await runMapiRequestAsync({
+            logger: data.logger,
+            func: async () => {
+                return (
+                    await data.client
+                        .uploadBinaryFile()
+                        .withData({
+                            binaryData: migrationAsset.binaryData,
+                            contentLength: geSizeInBytes(migrationAsset.binaryData),
+                            contentType: mime.getType(migrationAsset.filename) ?? '',
+                            filename: migrationAsset.filename
+                        })
+                        .toPromise()
+                ).data;
+            },
+            action: 'upload',
+            type: 'binaryFile',
+            logSpinner: logSpinner,
+            itemName: `${migrationAsset.title ?? migrationAsset.filename}`
+        });
+    };
+
+    const uploadAssetsAsync = async (
+        assetsToUpload: readonly MigrationAsset[]
+    ): Promise<readonly Readonly<AssetModels.Asset>[]> => {
+        data.logger.log({
+            type: 'upload',
+            message: `Uploading '${chalk.yellow(assetsToUpload.length.toString())}' assets`
+        });
+
+        return await processItemsAsync<MigrationAsset, Readonly<AssetModels.Asset>>({
+            action: 'Uploading assets',
+            logger: data.logger,
+            parallelLimit: 3,
+            items: assetsToUpload,
+            itemInfo: (input) => {
+                return {
+                    itemType: 'asset',
+                    title: input.title
+                };
+            },
+            processAsync: async (migrationAsset, logSpinner) => {
+                const uploadedBinaryFile = await uploadBinaryFileAsync(migrationAsset, logSpinner);
+
+                return await runMapiRequestAsync({
+                    logger: data.logger,
+                    func: async () =>
+                        (
+                            await data.client
+                                .addAsset()
+                                .withData(() => {
+                                    const assetStateInTargetEnv = data.importContext.getAssetStateInTargetEnvironment(
+                                        migrationAsset.codename
+                                    );
+
+                                    const assetRequestData: Readonly<AssetModels.IAddAssetRequestData> = {
+                                        file_reference: uploadedBinaryFile,
+                                        codename: migrationAsset.codename,
+                                        title: migrationAsset.title,
+                                        external_id: assetStateInTargetEnv.externalIdToUse,
+                                        collection: mapAssetCollection(migrationAsset.collection),
+                                        descriptions: mapAssetDescriptions(migrationAsset.descriptions)
+                                    };
+                                    return assetRequestData;
+                                })
+                                .toPromise()
+                        ).data,
+                    action: 'create',
+                    type: 'asset',
+                    logSpinner: logSpinner,
+                    itemName: `${migrationAsset.title ?? migrationAsset.filename}`
+                });
+            }
+        });
+    };
+
+    const importAsync = async (): Promise<Pick<ImportResult, 'editedAssets' | 'uploadedAssets'>> => {
+        return {
+            editedAssets: await editAssets(getAssetsToEdit()),
+            uploadedAssets: await uploadAssetsAsync(getAssetsToUpload())
+        };
+    };
+
+    return {
+        importAsync
+    };
+}

package/lib/import/importers/content-items-importer.ts

@@ -0,0 +1,142 @@
+import { ContentItemModels, ManagementClient } from '@kontent-ai/management-sdk';
+import {
+    Logger,
+    processItemsAsync,
+    runMapiRequestAsync,
+    MigrationItem,
+    LogSpinnerData,
+    findRequired
+} from '../../core/index.js';
+import chalk from 'chalk';
+import { ImportContext } from '../import.models.js';
+
+export function contentItemsImporter(data: {
+    readonly logger: Logger;
+    readonly client: Readonly<ManagementClient>;
+    readonly importContext: ImportContext;
+}) {
+    const shouldUpdateContentItem = (
+        migrationContentItem: MigrationItem,
+        contentItem: Readonly<ContentItemModels.ContentItem>
+    ): boolean => {
+        const collection = findRequired(
+            data.importContext.environmentData.collections,
+            (collection) => collection.codename === migrationContentItem.system.collection.codename,
+            `Invalid collection '${migrationContentItem.system.collection.codename}'`
+        );
+
+        return (
+            migrationContentItem.system.name !== contentItem.name ||
+            migrationContentItem.system.collection.codename !== collection.codename
+        );
+    };
+
+    const prepareContentItemAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationContentItem: MigrationItem
+    ): Promise<{ contentItem: Readonly<ContentItemModels.ContentItem>; status: 'created' | 'itemAlreadyExists' }> => {
+        const itemStateInTargetEnv = data.importContext.getItemStateInTargetEnvironment(
+            migrationContentItem.system.codename
+        );
+
+        if (itemStateInTargetEnv.state === 'exists' && itemStateInTargetEnv.item) {
+            return {
+                contentItem: itemStateInTargetEnv.item,
+                status: 'itemAlreadyExists'
+            };
+        }
+
+        const createdContentItem = await runMapiRequestAsync({
+            logger: data.logger,
+            func: async () =>
+                (
+                    await data.client
+                        .addContentItem()
+                        .withData({
+                            name: migrationContentItem.system.name,
+                            type: {
+                                codename: migrationContentItem.system.type.codename
+                            },
+                            external_id: itemStateInTargetEnv.externalIdToUse,
+                            codename: migrationContentItem.system.codename,
+                            collection: {
+                                codename: migrationContentItem.system.collection.codename
+                            }
+                        })
+                        .toPromise()
+                ).data,
+            action: 'create',
+            type: 'contentItem',
+            logSpinner: logSpinner,
+            itemName: `${migrationContentItem.system.codename} (${migrationContentItem.system.language.codename})`
+        });
+
+        return {
+            contentItem: createdContentItem,
+            status: 'created'
+        };
+    };
+
+    const importContentItemAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationItem: MigrationItem
+    ): Promise<Readonly<ContentItemModels.ContentItem>> => {
+        const preparedContentItemResult = await prepareContentItemAsync(logSpinner, migrationItem);
+
+        // check if name should be updated, no other changes are supported
+        if (preparedContentItemResult.status === 'itemAlreadyExists') {
+            if (shouldUpdateContentItem(migrationItem, preparedContentItemResult.contentItem)) {
+                await runMapiRequestAsync({
+                    logger: data.logger,
+                    func: async () => {
+                        await data.client
+                            .upsertContentItem()
+                            .byItemCodename(migrationItem.system.codename)
+                            .withData({
+                                name: migrationItem.system.name,
+                                collection: {
+                                    codename: migrationItem.system.collection.codename
+                                }
+                            })
+                            .toPromise();
+                    },
+                    action: 'upsert',
+                    type: 'contentItem',
+                    logSpinner: logSpinner,
+                    itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`
+                });
+            }
+        }
+
+        return preparedContentItemResult.contentItem;
+    };
+
+    const importAsync = async (): Promise<readonly Readonly<ContentItemModels.ContentItem>[]> => {
+        const contentItemsToImport = data.importContext.categorizedImportData.contentItems;
+
+        data.logger.log({
+            type: 'info',
+            message: `Importing '${chalk.yellow(contentItemsToImport.length.toString())}' content items`
+        });
+
+        return await processItemsAsync<MigrationItem, Readonly<ContentItemModels.ContentItem>>({
+            action: 'Importing content items',
+            logger: data.logger,
+            parallelLimit: 1,
+            items: contentItemsToImport,
+            itemInfo: (item) => {
+                return {
+                    itemType: 'contentItem',
+                    title: `${item.system.codename} -> ${item.system.language.codename}`
+                };
+            },
+            processAsync: async (item, logSpinner) => {
+                return await importContentItemAsync(logSpinner, item);
+            }
+        });
+    };
+
+    return {
+        importAsync
+    };
+}