@kontent-ai/migration-toolkit 1.3.0 → 1.5.0

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

@@ -2,27 +2,30 @@ import { AssetModels, ContentItemModels, LanguageVariantModels } from '@kontent-
 import {
     AssetStateInTargetEnvironmentByCodename,
     ItemStateInTargetEnvironmentByCodename,
+    LanguageVariantSchedulesStateValues,
+    LanguageVariantStateData,
     LanguageVariantStateInTargetEnvironmentByCodename,
+    LanguageVariantWorkflowState,
+    LanguageVariantWorkflowStateValues,
+    LogSpinnerData,
     MigrationItem,
+    WorkflowStep,
     findRequired,
     is404Error,
     isNotUndefined,
     managementClientUtils,
     processItemsAsync,
     runMapiRequestAsync,
-    workflowHelper
+    workflowHelper as workflowHelperInit
 } from '../../core/index.js';
-import {
-    GetFlattenedElementByCodenames,
-    ImportContext,
-    ImportContextConfig,
-    ImportContextEnvironmentData
-} from '../import.models.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';
 
 interface LanguageVariantWrapper {
-    readonly languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant>;
+    readonly draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
+    readonly publishedLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
     readonly migrationItem: MigrationItem;
 }
 
@@ -37,7 +40,8 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                 collections: await mapiUtils.getAllCollectionsAsync(spinnerData),
                 languages: await mapiUtils.getAllLanguagesAsync(spinnerData),
                 workflows: await mapiUtils.getAllWorkflowsAsync(spinnerData),
-                types: await mapiUtils.getFlattenedContentTypesAsync(spinnerData)
+                types: await mapiUtils.getFlattenedContentTypesAsync(spinnerData),
+                assetFolders: await mapiUtils.getAllAssetFoldersAsync(spinnerData)
             };
 
             spinnerData({ type: 'info', message: `Environmental data loaded` });
@@ -47,13 +51,10 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
     };
 
     const environmentData = await getEnvironmentDataAsync();
+    const workflowHelper = workflowHelperInit(environmentData.workflows);
 
     const getElement = () => {
-        const getFlattenedElement: GetFlattenedElementByCodenames = (
-            contentTypeCodename,
-            elementCodename,
-            sourceType
-        ) => {
+        const getFlattenedElement: GetFlattenedElementByCodenames = (contentTypeCodename, elementCodename, sourceType) => {
             const contentType = findRequired(
                 environmentData.types,
                 (type) => type.contentTypeCodename === contentTypeCodename,
@@ -65,9 +66,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                 (element) => element.codename === elementCodename,
                 `Element type with codename '${chalk.red(elementCodename)}' was not found in content type '${chalk.red(
                     contentTypeCodename
-                )}'. Available elements are '${contentType.elements
-                    .map((element) => chalk.yellow(element.codename))
-                    .join(', ')}'`
+                )}'. Available elements are '${contentType.elements.map((element) => chalk.yellow(element.codename)).join(', ')}'`
             );
 
             if (sourceType !== element.type) {
@@ -84,7 +83,70 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
         return getFlattenedElement;
     };
 
-    const getLanguageVariantsAsync = async (
+    const getLatestLanguageVariantAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationItem: MigrationItem
+    ): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined> => {
+        try {
+            const latestLanguageVariant = await runMapiRequestAsync({
+                logger: config.logger,
+                func: async () =>
+                    (
+                        await config.managementClient
+                            .viewLanguageVariant()
+                            .byItemCodename(migrationItem.system.codename)
+                            .byLanguageCodename(migrationItem.system.language.codename)
+                            .toPromise()
+                    ).data,
+                action: 'view',
+                type: 'languageVariant',
+                logSpinner: logSpinner,
+                itemName: `latest -> codename -> ${migrationItem.system.codename} (${migrationItem.system.language.codename})`
+            });
+
+            return latestLanguageVariant;
+        } catch (error) {
+            if (!is404Error(error)) {
+                throw error;
+            }
+
+            return undefined;
+        }
+    };
+
+    const getPublishedLanguageVariantAsync = async (
+        logSpinner: LogSpinnerData,
+        migrationItem: MigrationItem
+    ): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined> => {
+        try {
+            const draftLanguageVariant = await runMapiRequestAsync({
+                logger: config.logger,
+                func: async () =>
+                    (
+                        await config.managementClient
+                            .viewLanguageVariant()
+                            .byItemCodename(migrationItem.system.codename)
+                            .byLanguageCodename(migrationItem.system.language.codename)
+                            .published()
+                            .toPromise()
+                    ).data,
+                action: 'view',
+                type: 'languageVariant',
+                logSpinner: logSpinner,
+                itemName: `published -> codename -> ${migrationItem.system.codename} (${migrationItem.system.language.codename})`
+            });
+
+            return draftLanguageVariant;
+        } catch (error) {
+            if (!is404Error(error)) {
+                throw error;
+            }
+
+            return undefined;
+        }
+    };
+
+    const getLanguageVariantWrappersAsync = async (
         migrationItems: readonly MigrationItem[]
     ): Promise<readonly LanguageVariantWrapper[]> => {
         return (
@@ -100,34 +162,28 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                     };
                 },
                 processAsync: async (item, logSpinner) => {
-                    try {
-                        const languageVariant = await runMapiRequestAsync({
-                            logger: config.logger,
-                            func: async () =>
-                                (
-                                    await config.managementClient
-                                        .viewLanguageVariant()
-                                        .byItemCodename(item.system.codename)
-                                        .byLanguageCodename(item.system.language.codename)
-                                        .toPromise()
-                                ).data,
-                            action: 'view',
-                            type: 'languageVariant',
-                            logSpinner: logSpinner,
-                            itemName: `codename -> ${item.system.codename} (${item.system.language.codename})`
-                        });
+                    const latestLanguageVariant = await getLatestLanguageVariantAsync(logSpinner, item);
 
+                    if (!latestLanguageVariant) {
+                        // there is neither published or draft version as latest version does not exist at all
+                        return undefined;
+                    }
+
+                    if (workflowHelper.isPublishedStepById(latestLanguageVariant.workflow.stepIdentifier.id ?? '')) {
+                        // if latest version is published, it means that there is no draft, but there is published version
                         return {
-                            languageVariant: languageVariant,
-                            migrationItem: item
+                            migrationItem: item,
+                            draftLanguageVariant: undefined,
+                            publishedLanguageVariant: latestLanguageVariant
                         };
-                    } catch (error) {
-                        if (!is404Error(error)) {
-                            throw error;
-                        }
-
-                        return undefined;
                     }
+
+                    // if latest version is a draft version,  check if there is published version as well
+                    return {
+                        migrationItem: item,
+                        draftLanguageVariant: latestLanguageVariant,
+                        publishedLanguageVariant: await getPublishedLanguageVariantAsync(logSpinner, item)
+                    };
                 }
             })
         ).filter(isNotUndefined);
@@ -152,10 +208,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                     try {
                         return await runMapiRequestAsync({
                             logger: config.logger,
-                            func: async () =>
-                                (
-                                    await config.managementClient.viewContentItem().byItemCodename(codename).toPromise()
-                                ).data,
+                            func: async () => (await config.managementClient.viewContentItem().byItemCodename(codename).toPromise()).data,
                             action: 'view',
                             type: 'contentItem',
                             logSpinner: logSpinner,
@@ -173,9 +226,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
         ).filter(isNotUndefined);
     };
 
-    const getAssetsByCodenamesAsync = async (
-        assetCodenames: ReadonlySet<string>
-    ): Promise<readonly AssetModels.Asset[]> => {
+    const getAssetsByCodenamesAsync = async (assetCodenames: ReadonlySet<string>): Promise<readonly AssetModels.Asset[]> => {
         return (
             await processItemsAsync<string, Readonly<AssetModels.Asset> | undefined>({
                 action: 'Fetching assets',
@@ -192,10 +243,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                     try {
                         return await runMapiRequestAsync({
                             logger: config.logger,
-                            func: async () =>
-                                (
-                                    await config.managementClient.viewAsset().byAssetCodename(codename).toPromise()
-                                ).data,
+                            func: async () => (await config.managementClient.viewAsset().byAssetCodename(codename).toPromise()).data,
                             action: 'view',
                             type: 'asset',
                             logSpinner: logSpinner,
@@ -213,44 +261,98 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
         ).filter(isNotUndefined);
     };
 
+    const getVariantState = (languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant>): LanguageVariantStateData => {
+        const variantWorkflowId = languageVariant.workflow.workflowIdentifier.id;
+        const variantStepId = languageVariant.workflow.stepIdentifier.id;
+        const { workflow, step } = workflowHelper.getWorkflowAndStep({
+            workflowMatcher: {
+                errorMessage: `Could not workflow with id '${chalk.red(variantWorkflowId)}' in target project`,
+                match: (workflow) => workflow.id == variantWorkflowId
+            },
+            stepMatcher: {
+                errorMessage: `Could not workflow step with id '${chalk.red(variantStepId)}' in workflow '${chalk.yellow(
+                    variantWorkflowId
+                )}'`,
+                match: (step) => step.id == variantStepId
+            }
+        });
+
+        return {
+            languageVariant: languageVariant,
+            workflow: workflow,
+            workflowState: getWorkflowState(step, languageVariant)
+        };
+    };
+
     const getVariantStatesAsync = async (
         migrationItems: readonly MigrationItem[]
     ): Promise<readonly LanguageVariantStateInTargetEnvironmentByCodename[]> => {
-        const variants = await getLanguageVariantsAsync(migrationItems);
+        const variantWrappers = await getLanguageVariantWrappersAsync(migrationItems);
 
         return migrationItems.map<LanguageVariantStateInTargetEnvironmentByCodename>((migrationItem) => {
-            const variant = variants.find(
+            const variantWrapper = variantWrappers.find(
                 (m) =>
                     m.migrationItem.system.codename === migrationItem.system.codename &&
                     m.migrationItem.system.language === migrationItem.system.language
             );
 
-            const variantWorkflowId = variant?.languageVariant?.workflow?.workflowIdentifier?.id;
-            const variantStepId = variant?.languageVariant?.workflow?.stepIdentifier?.id;
-
-            const workflow = environmentData.workflows.find((workflow) => workflow.id === variantWorkflowId);
-
             return {
                 itemCodename: migrationItem.system.codename,
                 languageCodename: migrationItem.system.language.codename,
-                languageVariant: variant?.languageVariant,
-                workflow: workflow,
-                step: workflow
-                    ? workflowHelper(environmentData.workflows).getWorkflowStep(workflow, {
-                          errorMessage: `Could not workflow step with id '${chalk.red(
-                              variantStepId
-                          )}' in workflow '${chalk.yellow(workflow.codename)}'`,
-                          match: (step) => step.id == variantStepId
-                      })
+                draftLanguageVariant: variantWrapper?.draftLanguageVariant
+                    ? getVariantState(variantWrapper.draftLanguageVariant)
                     : undefined,
-                state: variant ? 'exists' : 'doesNotExists'
+                publishedLanguageVariant: variantWrapper?.publishedLanguageVariant
+                    ? getVariantState(variantWrapper.publishedLanguageVariant)
+                    : undefined,
+                state: variantWrapper ? 'exists' : 'doesNotExists'
             };
         });
     };
 
-    const getItemStatesAsync = async (
-        itemCodenames: ReadonlySet<string>
-    ): Promise<readonly ItemStateInTargetEnvironmentByCodename[]> => {
+    const getWorkflowState = (
+        step: Readonly<WorkflowStep>,
+        variant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined
+    ): LanguageVariantWorkflowState => {
+        if (!variant) {
+            return undefined;
+        }
+
+        const getScheduledState = (): LanguageVariantSchedulesStateValues => {
+            return match(variant.schedule)
+                .returnType<LanguageVariantSchedulesStateValues>()
+                .when(
+                    (schedule) => schedule.publishTime && schedule.publishDisplayTimezone,
+                    () => 'scheduledPublish'
+                )
+                .when(
+                    (schedule) => schedule.unpublishTime && schedule.unpublishDisplayTimezone,
+                    () => 'scheduledUnpublish'
+                )
+                .otherwise(() => 'n/a');
+        };
+
+        const getWorkflowState = (): LanguageVariantWorkflowStateValues => {
+            return match(step.codename)
+                .returnType<LanguageVariantWorkflowStateValues>()
+                .when(
+                    (stepCodename) => workflowHelper.isPublishedStepByCodename(stepCodename),
+                    () => 'published'
+                )
+                .when(
+                    (stepCodename) => workflowHelper.isArchivedStepByCodename(stepCodename),
+                    () => 'archived'
+                )
+                .otherwise(() => 'draft');
+        };
+
+        return {
+            workflowState: getWorkflowState(),
+            scheduledState: getScheduledState()
+        };
+    };
+
+    const getItemStatesAsync = async (itemCodenames: ReadonlySet<string>): Promise<readonly ItemStateInTargetEnvironmentByCodename[]> => {
         const items = await getContentItemsByCodenamesAsync(itemCodenames);
 
         return Array.from(itemCodenames).map<ItemStateInTargetEnvironmentByCodename>((codename) => {
@@ -311,17 +413,13 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
         ]);
 
         // prepare state of objects in target environment
-        const itemStates: readonly ItemStateInTargetEnvironmentByCodename[] = await getItemStatesAsync(
-            itemCodenamesToCheckInTargetEnv
-        );
+        const itemStates: readonly ItemStateInTargetEnvironmentByCodename[] = await getItemStatesAsync(itemCodenamesToCheckInTargetEnv);
 
         const variantStates: readonly LanguageVariantStateInTargetEnvironmentByCodename[] = await getVariantStatesAsync(
             config.migrationData.items
         );
 
-        const assetStates: readonly AssetStateInTargetEnvironmentByCodename[] = await getAssetStatesAsync(
-            assetCodenamesToCheckInTargetEnv
-        );
+        const assetStates: readonly AssetStateInTargetEnvironmentByCodename[] = await getAssetStatesAsync(assetCodenamesToCheckInTargetEnv);
 
         return {
             environmentData,
@@ -334,9 +432,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                 return findRequired(
                     itemStates,
                     (state) => state.itemCodename === itemCodename,
-                    `Invalid state for item '${chalk.red(
-                        itemCodename
-                    )}'. It is expected that all item states will be initialized`
+                    `Invalid state for item '${chalk.red(itemCodename)}'. It is expected that all item states will be initialized`
                 );
             },
             getLanguageVariantStateInTargetEnvironment: (itemCodename, languageCodename) => {
@@ -352,9 +448,7 @@ export async function importContextFetcherAsync(config: ImportContextConfig) {
                 return findRequired(
                     assetStates,
                     (state) => state.assetCodename === assetCodename,
-                    `Invalid state for asset '${chalk.red(
-                        assetCodename
-                    )}'. It is expected that all asset states will be initialized`
+                    `Invalid state for asset '${chalk.red(assetCodename)}'. It is expected that all asset states will be initialized`
                 );
             },
             getElement: getElementByCodenames

package/lib/import/import.models.ts

@@ -15,6 +15,7 @@ import {
     FlattenedContentType
 } from '../core/index.js';
 import {
+    AssetFolderModels,
     AssetModels,
     CollectionModels,
     ContentItemModels,
@@ -34,6 +35,7 @@ export interface ImportContextConfig {
 
 export interface ImportContextEnvironmentData {
     readonly languages: readonly Readonly<LanguageModels.LanguageModel>[];
+    readonly assetFolders: readonly Readonly<AssetFolderModels.AssetFolder>[];
     readonly collections: readonly Readonly<CollectionModels.Collection>[];
     readonly workflows: readonly Readonly<WorkflowModels.Workflow>[];
     readonly types: readonly Readonly<FlattenedContentType>[];

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

@@ -1,4 +1,4 @@
-import { AssetModels, ManagementClient } from '@kontent-ai/management-sdk';
+import { AssetModels, ManagementClient, SharedContracts } from '@kontent-ai/management-sdk';
 import {
     MigrationAsset,
     Logger,
@@ -45,6 +45,7 @@ export function assetsImporter(data: {
                     !shouldUpdateAsset({
                         collections: data.importContext.environmentData.collections,
                         languages: data.importContext.environmentData.languages,
+                        assetFolders: data.importContext.environmentData.assetFolders,
                         migrationAsset: migrationAsset,
                         targetAsset: assetState.asset
                     })
@@ -64,9 +65,7 @@ export function assetsImporter(data: {
             .filter(isNotUndefined);
     };
 
-    const editAssets = async (
-        assetsToEdit: readonly AssetToEdit[]
-    ): Promise<readonly Readonly<AssetModels.Asset>[]> => {
+    const editAssets = async (assetsToEdit: readonly AssetToEdit[]): Promise<readonly Readonly<AssetModels.Asset>[]> => {
         data.logger.log({
             type: 'upsert',
             message: `Upserting '${chalk.yellow(assetsToEdit.length.toString())}' assets`
@@ -100,11 +99,10 @@ export function assetsImporter(data: {
                                 .withData(() => {
                                     return {
                                         title: assetEditRequest.migrationAsset.title,
-                                        descriptions: mapAssetDescriptions(
-                                            assetEditRequest.migrationAsset.descriptions
-                                        ),
+                                        descriptions: mapAssetDescriptions(assetEditRequest.migrationAsset.descriptions),
                                         collection: mapAssetCollection(assetEditRequest.migrationAsset.collection),
-                                        file_reference: uploadedBinaryFile ?? undefined
+                                        file_reference: uploadedBinaryFile ?? undefined,
+                                        folder: mapAssetFolder(assetEditRequest.migrationAsset.folder)
                                     };
                                 })
                                 .toPromise()
@@ -131,6 +129,16 @@ export function assetsImporter(data: {
             : undefined;
     };
 
+    const mapAssetFolder = (
+        migrationFolder: MigrationReference | undefined
+    ): Readonly<SharedContracts.IReferenceObjectContract> | undefined => {
+        return migrationFolder
+            ? {
+                  codename: migrationFolder.codename
+              }
+            : undefined;
+    };
+
     const mapAssetDescriptions = (
         migrationDescription: readonly MigrationAssetDescription[] | undefined
     ): Readonly<AssetModels.IAssetFileDescription>[] => {
@@ -172,9 +180,7 @@ export function assetsImporter(data: {
         });
     };
 
-    const uploadAssetsAsync = async (
-        assetsToUpload: readonly MigrationAsset[]
-    ): Promise<readonly Readonly<AssetModels.Asset>[]> => {
+    const uploadAssetsAsync = async (assetsToUpload: readonly MigrationAsset[]): Promise<readonly Readonly<AssetModels.Asset>[]> => {
         data.logger.log({
             type: 'upload',
             message: `Uploading '${chalk.yellow(assetsToUpload.length.toString())}' assets`
@@ -211,7 +217,8 @@ export function assetsImporter(data: {
                                         title: migrationAsset.title,
                                         external_id: assetStateInTargetEnv.externalIdToUse,
                                         collection: mapAssetCollection(migrationAsset.collection),
-                                        descriptions: mapAssetDescriptions(migrationAsset.descriptions)
+                                        descriptions: mapAssetDescriptions(migrationAsset.descriptions),
+                                        folder: mapAssetFolder(migrationAsset.folder)
                                     };
                                     return assetRequestData;
                                 })