@kontent-ai/migration-toolkit 1.4.0 → 1.5.1

package/lib/import/importers/language-variant-importer.ts

@@ -1,3 +1,4 @@
+import { match } from 'ts-pattern';
 import { ContentItemModels, ElementContracts, LanguageVariantModels, ManagementClient, WorkflowModels } from '@kontent-ai/management-sdk';
 import {
     Logger,
@@ -8,12 +9,15 @@ import {
     MigrationElement,
     MigrationItemVersion,
     workflowHelper,
-    findRequired
+    findRequired,
+    isNotUndefined,
+    LanguageVariantSchedulesStateValues,
+    LanguageVariantStateInTargetEnvironmentByCodename
 } from '../../core/index.js';
 import chalk from 'chalk';
 import { ImportContext } from '../import.models.js';
 import { importTransforms } from '../../translation/index.js';
-import { workflowImporter } from './workflow-importer.js';
+import { workflowImporter as workflowImporterInit } from './workflow-importer.js';
 import { throwErrorForMigrationItem } from '../utils/import.utils.js';
 
 export function languageVariantImporter(config: {
@@ -22,6 +26,12 @@ export function languageVariantImporter(config: {
     readonly importContext: ImportContext;
     readonly client: Readonly<ManagementClient>;
 }) {
+    const workflowImporter = workflowImporterInit({
+        logger: config.logger,
+        managementClient: config.client,
+        workflows: config.importContext.environmentData.workflows
+    });
+
     const upsertLanguageVariantAsync = async (data: {
         readonly workflow: Readonly<WorkflowModels.Workflow>;
         readonly logSpinner: LogSpinnerData;
@@ -86,7 +96,7 @@ export function languageVariantImporter(config: {
         if (draftVersions.length > 1) {
             throwErrorForMigrationItem(
                 migrationItem,
-                `There can be only 1 draft version. There are '${publishedVersions.length}' draft versions for the item.`
+                `There can be only 1 draft version. There are '${draftVersions.length}' draft versions for the item.`
             );
         }
 
@@ -101,7 +111,7 @@ export function languageVariantImporter(config: {
         readonly migrationItem: MigrationItem;
         readonly migrationItemVersion: MigrationItemVersion;
         readonly preparedContentItem: Readonly<ContentItemModels.ContentItem>;
-        readonly workflowStepCodenameInTargetEnvironment: string | undefined;
+        readonly createNewVersion?: boolean;
     }): Promise<Readonly<LanguageVariantModels.ContentItemLanguageVariant>> => {
         // validate workflow
         const { step, workflow } = workflowHelper(config.importContext.environmentData.workflows).getWorkflowAndStepByCodenames({
@@ -109,16 +119,13 @@ export function languageVariantImporter(config: {
             stepCodename: data.migrationItemVersion.workflow_step.codename
         });
 
-        // prepare target variant for upsert if it exists in target env
-        if (data.workflowStepCodenameInTargetEnvironment) {
-            await prepareLanguageVariantForImportAsync({
+        // create new version if necessary. This is needed when both draft & published version are imported
+        if (data.createNewVersion) {
+            await workflowImporter.createNewVersionOfLanguageVariantAsync({
                 logSpinner: data.logSpinner,
-                workflowStepCodenameInTargetEnvironment: data.workflowStepCodenameInTargetEnvironment,
-                migrationItem: data.migrationItem,
-                workflow
+                migrationItem: data.migrationItem
             });
         }
-
         // upsert language variant
         const languageVariant = await upsertLanguageVariantAsync({
             logSpinner: data.logSpinner,
@@ -129,15 +136,19 @@ export function languageVariantImporter(config: {
         });
 
         // set workflow accordingly (publish, move to workflow step, archive ...)
-        await workflowImporter({
-            logger: config.logger,
-            managementClient: config.client,
-            workflows: config.importContext.environmentData.workflows
-        }).setWorkflowOfLanguageVariantAsync({
+        await workflowImporter.setWorkflowOfLanguageVariantAsync({
             logSpinner: data.logSpinner,
             migrationItem: data.migrationItem,
             workflowCodename: workflow.codename,
-            stepCodename: step.codename
+            stepCodename: step.codename,
+            migrationItemVersion: data.migrationItemVersion
+        });
+
+        // set scheduling
+        await workflowImporter.setScheduledStateOfLanguageVariantAsync({
+            logSpinner: data.logSpinner,
+            migrationItem: data.migrationItem,
+            migrationItemVersion: data.migrationItemVersion
         });
 
         return languageVariant;
@@ -150,127 +161,124 @@ export function languageVariantImporter(config: {
     ): Promise<readonly LanguageVariantModels.ContentItemLanguageVariant[]> => {
         const { draftVersion, publishedVersion } = categorizeVersions(migrationItem);
 
-        let publishedLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
-        let draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
-        let lastWorkflowStepCodenameInTargetEnvironment: string | undefined;
-
-        const workflow = workflowHelper(config.importContext.environmentData.workflows).getWorkflowByCodename(
-            migrationItem.system.workflow.codename
-        );
-
         // get initial state of language variant from target env
-        const languageVariantState = config.importContext.getLanguageVariantStateInTargetEnvironment(
+        const targetVariantState = config.importContext.getLanguageVariantStateInTargetEnvironment(
             migrationItem.system.codename,
             migrationItem.system.language.codename
         );
 
-        if (languageVariantState.step) {
-            // keep track of last worfklow step
-            lastWorkflowStepCodenameInTargetEnvironment = languageVariantState.step.codename;
-        }
+        // prepare language variant for import (unpublish, create new version, un-schedule ...)
+        await prepareTargetEnvironmentVariantForImportAsync({
+            logSpinner,
+            migrationItem,
+            targetVariantState
+        });
 
         // first import published version if it exists
-        if (publishedVersion) {
-            publishedLanguageVariant = await importVersionAsync({
-                logSpinner: logSpinner,
-                migrationItem: migrationItem,
-                preparedContentItem: preparedContentItem,
-                migrationItemVersion: publishedVersion,
-                workflowStepCodenameInTargetEnvironment: lastWorkflowStepCodenameInTargetEnvironment
+        const publishedLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined = publishedVersion
+            ? await importVersionAsync({
+                  logSpinner: logSpinner,
+                  migrationItem: migrationItem,
+                  preparedContentItem: preparedContentItem,
+                  migrationItemVersion: publishedVersion
+              })
+            : undefined;
+
+        // if target env contains published version & imported version not, unpublish it from the target env
+        if (targetVariantState.publishedLanguageVariant && !publishedVersion) {
+            await workflowImporter.unpublishLanguageVariantAsync({
+                logSpinner,
+                migrationItem
             });
-
-            // set last published workflow step to publish as language variant has just been published in target environment
-            lastWorkflowStepCodenameInTargetEnvironment = workflow.publishedStep.codename;
-        }
-
-        if (draftVersion) {
-            draftLanguageVariant = await importVersionAsync({
-                logSpinner: logSpinner,
-                migrationItem: migrationItem,
-                preparedContentItem: preparedContentItem,
-                migrationItemVersion: draftVersion,
-                workflowStepCodenameInTargetEnvironment: lastWorkflowStepCodenameInTargetEnvironment
+            await workflowImporter.moveToDraftStepAsync({
+                logSpinner,
+                migrationItem
             });
         }
-
-        return [...(publishedLanguageVariant ? [publishedLanguageVariant] : []), ...(draftLanguageVariant ? [draftLanguageVariant] : [])];
-    };
-
-    const createNewVersionOfLanguageVariantAsync = async (logSpinner: LogSpinnerData, migrationItem: MigrationItem): Promise<void> => {
-        await runMapiRequestAsync({
-            logger: config.logger,
-            func: async () => {
-                await config.client
-                    .createNewVersionOfLanguageVariant()
-                    .byItemCodename(migrationItem.system.codename)
-                    .byLanguageCodename(migrationItem.system.language.codename)
-                    .toPromise();
-            },
-            action: 'createNewVersion',
-            type: 'languageVariant',
-            logSpinner: logSpinner,
-            itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename})`
-        });
+        const draftLanguageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined = draftVersion
+            ? await importVersionAsync({
+                  logSpinner: logSpinner,
+                  migrationItem: migrationItem,
+                  preparedContentItem: preparedContentItem,
+                  migrationItemVersion: draftVersion,
+                  createNewVersion: publishedLanguageVariant ? true : false
+              })
+            : undefined;
+
+        return [publishedLanguageVariant, draftLanguageVariant].filter(isNotUndefined);
     };
 
-    const moveToDraftStepAsync = async (
-        logSpinner: LogSpinnerData,
-        migrationItem: MigrationItem,
-        workflow: Readonly<WorkflowModels.Workflow>
-    ): Promise<void> => {
-        const firstWorkflowStep = workflow.steps?.[0];
+    const cancelScheduledStateAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly scheduledState: LanguageVariantSchedulesStateValues;
+    }): Promise<void> => {
+        const changeWorkflowData = {
+            logSpinner: data.logSpinner,
+            migrationItem: data.migrationItem
+        };
 
-        if (firstWorkflowStep) {
-            await runMapiRequestAsync({
-                logger: config.logger,
-                func: async () => {
-                    await config.client
-                        .changeWorkflowOfLanguageVariant()
-                        .byItemCodename(migrationItem.system.codename)
-                        .byLanguageCodename(migrationItem.system.language.codename)
-                        .withData({
-                            workflow_identifier: {
-                                codename: workflow.codename
-                            },
-                            step_identifier: {
-                                codename: firstWorkflowStep.codename
-                            }
-                        })
-                        .toPromise();
-                },
-                action: 'changeWorkflowStep',
-                type: 'languageVariant',
-                logSpinner: logSpinner,
-                itemName: `${migrationItem.system.codename} (${migrationItem.system.language.codename}) -> ${firstWorkflowStep.codename}`
-            });
-        }
+        await match(data.scheduledState)
+            .with('scheduledPublish', async () => {
+                // cancel scheduled publish if language variant is scheduled to be published
+                await workflowImporter.cancelScheduledPublishAsync(changeWorkflowData);
+            })
+            .with('scheduledUnpublish', async () => {
+                // cancel scheduled unpublish if language variant is scheduled to be unpublished
+                await workflowImporter.cancelScheduledUnpublishAsync(changeWorkflowData);
+            })
+            .otherwise(() => {});
     };
 
-    const prepareLanguageVariantForImportAsync = async (data: {
+    const prepareTargetEnvironmentVariantForImportAsync = async (data: {
         readonly logSpinner: LogSpinnerData;
         readonly migrationItem: MigrationItem;
-        readonly workflowStepCodenameInTargetEnvironment: string;
-        readonly workflow: Readonly<WorkflowModels.Workflow>;
+        readonly targetVariantState: LanguageVariantStateInTargetEnvironmentByCodename;
     }): Promise<void> => {
-        // create new version if language variant is published
-        if (isPublishedWorkflowStep(data.workflowStepCodenameInTargetEnvironment, data.workflow)) {
-            await createNewVersionOfLanguageVariantAsync(data.logSpinner, data.migrationItem);
+        if (!data.targetVariantState) {
+            // no need to prepare language variant as it doesn't exist in target environment
+            return;
         }
 
-        // move to draft step if language variant is archived
-        if (isArchivedWorkflowStep(data.workflowStepCodenameInTargetEnvironment, data.workflow)) {
-            await moveToDraftStepAsync(data.logSpinner, data.migrationItem, data.workflow);
+        // when language variant exists in target env, we need to prepare it for import by unscheduling, moving to draft etc...
+        // we use draft language variant if it exists, otherwise we use published language variant
+        const languageVariantToPrepare = data.targetVariantState.draftLanguageVariant ?? data.targetVariantState.publishedLanguageVariant;
+
+        if (!languageVariantToPrepare) {
+            return;
         }
+
+        // there is likely a bug which causes /published endpoint to return invalid scheduled state
+        // use conditions below to determine scheduled state to use - this will be fixed in future
+        if (languageVariantToPrepare.workflowState?.scheduledState) {
+            await cancelScheduledStateAsync({
+                logSpinner: data.logSpinner,
+                migrationItem: data.migrationItem,
+                scheduledState: languageVariantToPrepare.workflowState.scheduledState
+            });
+        }
+
+        const changeWorkflowData = {
+            logSpinner: data.logSpinner,
+            migrationItem: data.migrationItem
+        };
+
+        await match(languageVariantToPrepare.workflowState?.workflowState)
+            .with('published', async () => {
+                // create new version if language variant is published
+                await workflowImporter.createNewVersionOfLanguageVariantAsync(changeWorkflowData);
+            })
+            .with('archived', async () => {
+                // move to draft step if language variant is archived
+                await workflowImporter.moveToDraftStepAsync(changeWorkflowData);
+            })
+            .otherwise(() => {});
     };
 
     const isPublishedWorkflowStep = (stepCodename: string, workflow: Readonly<WorkflowModels.Workflow>): boolean => {
         return workflow.publishedStep.codename === stepCodename;
     };
 
-    const isArchivedWorkflowStep = (stepCodename: string, workflow: Readonly<WorkflowModels.Workflow>): boolean => {
-        return workflow.archivedStep.codename === stepCodename;
-    };
-
     const getElementContract = (
         migrationItem: MigrationItem,
         element: MigrationElement,

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

@@ -1,11 +1,21 @@
 import { ManagementClient, SharedModels, WorkflowModels } from '@kontent-ai/management-sdk';
-import { Logger, runMapiRequestAsync, LogSpinnerData, MigrationItem, workflowHelper } from '../../core/index.js';
+import {
+    Logger,
+    runMapiRequestAsync,
+    LogSpinnerData,
+    MigrationItem,
+    workflowHelper as workflowHelperInit,
+    MigrationItemVersion
+} from '../../core/index.js';
+import { match } from 'ts-pattern';
 
 export function workflowImporter(config: {
-    logger: Logger;
-    managementClient: Readonly<ManagementClient>;
-    workflows: readonly Readonly<WorkflowModels.Workflow>[];
+    readonly logger: Logger;
+    readonly managementClient: Readonly<ManagementClient>;
+    readonly workflows: readonly Readonly<WorkflowModels.Workflow>[];
 }) {
+    const workflowHelper = workflowHelperInit(config.workflows);
+
     const publishLanguageVariantAsync = async (data: {
         readonly logSpinner: LogSpinnerData;
         readonly migrationItem: MigrationItem;
@@ -64,12 +74,70 @@ export function workflowImporter(config: {
         }
     };
 
+    const schedulePublishLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly schedule: {
+            readonly publish_time: string;
+            readonly publish_display_timezone: string;
+        };
+    }): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () =>
+                (
+                    await config.managementClient
+                        .publishLanguageVariant()
+                        .byItemCodename(data.migrationItem.system.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withData({
+                            scheduled_to: data.schedule.publish_time,
+                            display_timezone: data.schedule.publish_display_timezone
+                        })
+                        .toPromise()
+                ).data,
+            action: 'schedulePublish',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename})`
+        });
+    };
+
+    const scheduleUnpublishLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly schedule: {
+            readonly unpublish_time: string;
+            readonly unpublish_display_timezone: string;
+        };
+    }): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () =>
+                (
+                    await config.managementClient
+                        .unpublishLanguageVariant()
+                        .byItemCodename(data.migrationItem.system.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withData({
+                            scheduled_to: data.schedule.unpublish_time,
+                            display_timezone: data.schedule.unpublish_display_timezone
+                        })
+                        .toPromise()
+                ).data,
+            action: 'scheduleUnpublish',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename})`
+        });
+    };
+
     const archiveLanguageVariantAsync = async (data: {
         readonly logSpinner: LogSpinnerData;
         readonly workflowCodename: string;
         readonly migrationItem: MigrationItem;
     }): Promise<void> => {
-        const workflow = workflowHelper(config.workflows).getWorkflowByCodename(data.workflowCodename);
+        const workflow = workflowHelper.getWorkflowByCodename(data.workflowCodename);
         await runMapiRequestAsync({
             logger: config.logger,
             func: async () =>
@@ -101,7 +169,7 @@ export function workflowImporter(config: {
         readonly stepCodename: string;
         readonly migrationItem: MigrationItem;
     }): Promise<void> => {
-        const { workflow, step } = workflowHelper(config.workflows).getWorkflowAndStepByCodenames({
+        const { workflow, step } = workflowHelper.getWorkflowAndStepByCodenames({
             workflowCodename: data.workflowCodename,
             stepCodename: data.stepCodename
         });
@@ -131,29 +199,169 @@ export function workflowImporter(config: {
         });
     };
 
+    const createNewVersionOfLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () => {
+                await config.managementClient
+                    .createNewVersionOfLanguageVariant()
+                    .byItemCodename(data.migrationItem.system.codename)
+                    .byLanguageCodename(data.migrationItem.system.language.codename)
+                    .toPromise();
+            },
+            action: 'createNewVersion',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename})`
+        });
+    };
+
+    const cancelScheduledPublishAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () => {
+                await config.managementClient
+                    .cancelSheduledPublishingOfLanguageVariant()
+                    .byItemCodename(data.migrationItem.system.codename)
+                    .byLanguageCodename(data.migrationItem.system.language.codename)
+                    .toPromise();
+            },
+            action: 'cancelScheduledPublish',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> Cancel scheduled publish`
+        });
+    };
+
+    const cancelScheduledUnpublishAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        await runMapiRequestAsync({
+            logger: config.logger,
+            func: async () => {
+                await config.managementClient
+                    .cancelSheduledUnpublishingOfLanguageVariant()
+                    .byItemCodename(data.migrationItem.system.codename)
+                    .byLanguageCodename(data.migrationItem.system.language.codename)
+                    .toPromise();
+            },
+            action: 'cancelScheduledUnpublish',
+            type: 'languageVariant',
+            logSpinner: data.logSpinner,
+            itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> Cancel scheduled unpublish`
+        });
+    };
+
+    const moveToDraftStepAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+    }): Promise<void> => {
+        const workflow = workflowHelper.getWorkflowByCodename(data.migrationItem.system.workflow.codename);
+        const firstWorkflowStep = workflow.steps?.[0];
+
+        if (firstWorkflowStep) {
+            await runMapiRequestAsync({
+                logger: config.logger,
+                func: async () => {
+                    await config.managementClient
+                        .changeWorkflowOfLanguageVariant()
+                        .byItemCodename(data.migrationItem.system.codename)
+                        .byLanguageCodename(data.migrationItem.system.language.codename)
+                        .withData({
+                            workflow_identifier: {
+                                codename: workflow.codename
+                            },
+                            step_identifier: {
+                                codename: firstWorkflowStep.codename
+                            }
+                        })
+                        .toPromise();
+                },
+                action: 'changeWorkflowStep',
+                type: 'languageVariant',
+                logSpinner: data.logSpinner,
+                itemName: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> ${firstWorkflowStep.codename}`
+            });
+        }
+    };
+
+    const setScheduledStateOfLanguageVariantAsync = async (data: {
+        readonly logSpinner: LogSpinnerData;
+        readonly migrationItem: MigrationItem;
+        readonly migrationItemVersion: MigrationItemVersion;
+    }): Promise<void> => {
+        if (!data.migrationItemVersion.schedule) {
+            return;
+        }
+
+        // set scheduling
+        if (data.migrationItemVersion.schedule.unpublish_time && data.migrationItemVersion.schedule.unpublish_display_timezone) {
+            await scheduleUnpublishLanguageVariantAsync({
+                logSpinner: data.logSpinner,
+                migrationItem: data.migrationItem,
+                schedule: {
+                    unpublish_time: data.migrationItemVersion.schedule.unpublish_time,
+                    unpublish_display_timezone: data.migrationItemVersion.schedule.unpublish_display_timezone
+                }
+            });
+        }
+
+        if (data.migrationItemVersion.schedule.publish_time && data.migrationItemVersion.schedule.publish_display_timezone) {
+            await schedulePublishLanguageVariantAsync({
+                logSpinner: data.logSpinner,
+                migrationItem: data.migrationItem,
+                schedule: {
+                    publish_time: data.migrationItemVersion.schedule.publish_time,
+                    publish_display_timezone: data.migrationItemVersion.schedule.publish_display_timezone
+                }
+            });
+        }
+    };
+
     const setWorkflowOfLanguageVariantAsync = async (data: {
         readonly logSpinner: LogSpinnerData;
         readonly workflowCodename: string;
         readonly stepCodename: string;
         readonly migrationItem: MigrationItem;
+        readonly migrationItemVersion: MigrationItemVersion;
     }): Promise<void> => {
-        if (workflowHelper(config.workflows).isPublishedStepByCodename(data.stepCodename)) {
-            await publishLanguageVariantAsync(data);
-        } else if (workflowHelper(config.workflows).isScheduledStepByCodename(data.stepCodename)) {
-            data.logSpinner({
-                type: 'skip',
-                message: `${data.migrationItem.system.codename} (${data.migrationItem.system.language.codename}) -> Skipping scheduled workflow step assignment`
-            });
-        } else if (workflowHelper(config.workflows).isArchivedStepByCodename(data.stepCodename)) {
-            await unpublishLanguageVariantAsync(data);
-            await archiveLanguageVariantAsync(data);
-        } else {
-            await changeWorkflowOfLanguageVariantAsync(data);
-        }
+        return await match(data.stepCodename)
+            .returnType<Promise<void>>()
+            .when(
+                (stepCodename) => workflowHelper.isPublishedStepByCodename(stepCodename),
+                async () => await publishLanguageVariantAsync(data)
+            )
+            .when(
+                (stepCodename) => workflowHelper.isArchivedStepByCodename(stepCodename),
+                async () => await archiveLanguageVariantAsync(data)
+            )
+            .when(
+                (stepCodename) => workflowHelper.isScheduledStepByCodename(stepCodename),
+                async () => {
+                    // do nothing for scheduled step
+                    return await Promise.resolve();
+                }
+            )
+            .otherwise(async () => await changeWorkflowOfLanguageVariantAsync(data));
     };
 
     return {
+        setScheduledStateOfLanguageVariantAsync,
         setWorkflowOfLanguageVariantAsync,
-        publishLanguageVariantAsync
+        publishLanguageVariantAsync,
+        unpublishLanguageVariantAsync,
+        archiveLanguageVariantAsync,
+        changeWorkflowOfLanguageVariantAsync,
+        moveToDraftStepAsync,
+        createNewVersionOfLanguageVariantAsync,
+        cancelScheduledPublishAsync,
+        cancelScheduledUnpublishAsync
     };
 }

package/lib/metadata.ts

@@ -1,6 +1,6 @@
 
 export const libMetadata = {
 	name: '@kontent-ai/migration-toolkit',
-    timestamp: 'Tue, 30 Jul 2024 18:37:03 GMT',
-    version: '1.4.0'
+    timestamp: 'Mon, 09 Sep 2024 13:24:59 GMT',
+    version: '1.5.1'
 };

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) => {