@kontent-ai/migration-toolkit 1.3.0 → 1.5.0

package/lib/core/utils/management-client-utils.ts

@@ -1,182 +1,188 @@
-import {
-    CollectionModels,
-    ContentTypeModels,
-    ContentTypeSnippetModels,
-    EnvironmentModels,
-    LanguageModels,
-    ManagementClient,
-    TaxonomyModels,
-    WorkflowModels,
-    createManagementClient
-} from '@kontent-ai/management-sdk';
-import { IRetryStrategyOptions } from '@kontent-ai/core-sdk';
-import { runMapiRequestAsync } from './run.utils.js';
-import { LogSpinnerData, Logger } from '../models/log.models.js';
-import { FlattenedContentType, FlattenedContentTypeElement } from '../models/core.models.js';
-import { isNotUndefined } from './global.utils.js';
-import chalk from 'chalk';
-import { defaultHttpService, defaultRetryStrategy } from './http.utils.js';
-import { findRequired } from './array.utils.js';
-
-export interface ManagementClientConfig {
-    readonly environmentId: string;
-    readonly apiKey: string;
-    readonly retryStrategy?: Readonly<IRetryStrategyOptions>;
-    readonly baseUrl?: string;
-}
-
-export function getMigrationManagementClient(config: ManagementClientConfig): ManagementClient {
-    return createManagementClient({
-        environmentId: config.environmentId,
-        retryStrategy: config.retryStrategy ?? defaultRetryStrategy,
-        httpService: defaultHttpService,
-        apiKey: config.apiKey
-    });
-}
-
-export function managementClientUtils(client: Readonly<ManagementClient>, logger: Logger) {
-    const getEnvironmentAsync = async (): Promise<EnvironmentModels.EnvironmentInformationModel> => {
-        return (await client.environmentInformation().toPromise()).data.project;
-    };
-
-    const getAllLanguagesAsync = async (
-        logSpinner: LogSpinnerData
-    ): Promise<readonly LanguageModels.LanguageModel[]> => {
-        return await runMapiRequestAsync({
-            logSpinner: logSpinner,
-            logger: logger,
-            func: async () => (await client.listLanguages().toAllPromise()).data.items,
-            action: 'list',
-            type: 'language'
-        });
-    };
-
-    const getAllCollectionsAsync = async (
-        logSpinner: LogSpinnerData
-    ): Promise<readonly CollectionModels.Collection[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listCollections().toPromise()).data.collections,
-            action: 'list',
-            type: 'collection'
-        });
-    };
-
-    const getAllWorkflowsAsync = async (logSpinner: LogSpinnerData): Promise<readonly WorkflowModels.Workflow[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listWorkflows().toPromise()).data,
-            action: 'list',
-            type: 'workflow'
-        });
-    };
-
-    const getAllTaxonomiesAsync = async (logSpinner: LogSpinnerData): Promise<readonly TaxonomyModels.Taxonomy[]> => {
-        return await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listTaxonomies().toAllPromise()).data.items,
-            action: 'list',
-            type: 'taxonomy'
-        });
-    };
-
-    const getContentTypeElements = (
-        contentType: ContentTypeModels.ContentType,
-        contentTypeSnippets: readonly ContentTypeSnippetModels.ContentTypeSnippet[]
-    ): readonly FlattenedContentTypeElement[] => {
-        return contentType.elements
-            .flatMap((element) => {
-                if (!element.codename || !element.id) {
-                    return undefined;
-                }
-
-                if (element.type === 'guidelines') {
-                    return undefined;
-                }
-
-                if (element.type === 'snippet') {
-                    const snippetElement = element;
-
-                    // replace snippet element with actual elements
-                    const contentTypeSnippet = findRequired(
-                        contentTypeSnippets,
-                        (snippet) => snippet.id === snippetElement.snippet.id,
-                        `Could not find content type snippet for element. This snippet is referenced in type '${chalk.red(
-                            contentType.codename
-                        )}'`
-                    );
-
-                    return contentTypeSnippet.elements.map((snippetElement) => {
-                        if (snippetElement.type === 'guidelines' || snippetElement.type === 'snippet') {
-                            return undefined;
-                        }
-                        if (!snippetElement.codename || !snippetElement.id) {
-                            return undefined;
-                        }
-
-                        const flattenedElement: FlattenedContentTypeElement = {
-                            codename: snippetElement.codename,
-                            type: snippetElement.type,
-                            id: snippetElement.id,
-                            element: element
-                        };
-
-                        return flattenedElement;
-                    });
-                }
-                const flattenedElement: FlattenedContentTypeElement = {
-                    codename: element.codename,
-                    id: element.id,
-                    type: element.type,
-                    element: element
-                };
-
-                return flattenedElement;
-            })
-            .filter(isNotUndefined);
-    };
-
-    const getFlattenedContentTypesAsync = async (
-        logSpinner: LogSpinnerData
-    ): Promise<readonly FlattenedContentType[]> => {
-        const contentTypes = await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listContentTypes().toAllPromise()).data.items,
-            action: 'list',
-            type: 'contentType'
-        });
-
-        const contentTypeSnippets = await runMapiRequestAsync({
-            logger: logger,
-            logSpinner: logSpinner,
-            func: async () => (await client.listContentTypeSnippets().toAllPromise()).data.items,
-            action: 'list',
-            type: 'contentTypeSnippet'
-        });
-
-        return [
-            ...contentTypes.map((contentType) => {
-                const importType: FlattenedContentType = {
-                    contentTypeCodename: contentType.codename,
-                    contentTypeId: contentType.id,
-                    elements: getContentTypeElements(contentType, contentTypeSnippets)
-                };
-
-                return importType;
-            })
-        ];
-    };
-
-    return {
-        getAllCollectionsAsync,
-        getAllLanguagesAsync,
-        getAllWorkflowsAsync,
-        getAllTaxonomiesAsync,
-        getFlattenedContentTypesAsync,
-        getEnvironmentAsync
-    };
-}
+import {
+    AssetFolderModels,
+    CollectionModels,
+    ContentTypeModels,
+    ContentTypeSnippetModels,
+    EnvironmentModels,
+    LanguageModels,
+    ManagementClient,
+    TaxonomyModels,
+    WorkflowModels,
+    createManagementClient
+} from '@kontent-ai/management-sdk';
+import { IRetryStrategyOptions } from '@kontent-ai/core-sdk';
+import { runMapiRequestAsync } from './run.utils.js';
+import { LogSpinnerData, Logger } from '../models/log.models.js';
+import { FlattenedContentType, FlattenedContentTypeElement } from '../models/core.models.js';
+import { isNotUndefined } from './global.utils.js';
+import chalk from 'chalk';
+import { defaultHttpService, defaultRetryStrategy } from './http.utils.js';
+import { findRequired } from './array.utils.js';
+
+export interface ManagementClientConfig {
+    readonly environmentId: string;
+    readonly apiKey: string;
+    readonly retryStrategy?: Readonly<IRetryStrategyOptions>;
+    readonly baseUrl?: string;
+}
+
+export function getMigrationManagementClient(config: ManagementClientConfig): ManagementClient {
+    return createManagementClient({
+        environmentId: config.environmentId,
+        retryStrategy: config.retryStrategy ?? defaultRetryStrategy,
+        httpService: defaultHttpService,
+        apiKey: config.apiKey
+    });
+}
+
+export function managementClientUtils(client: Readonly<ManagementClient>, logger: Logger) {
+    const getEnvironmentAsync = async (): Promise<EnvironmentModels.EnvironmentInformationModel> => {
+        return (await client.environmentInformation().toPromise()).data.project;
+    };
+
+    const getAllLanguagesAsync = async (logSpinner: LogSpinnerData): Promise<readonly LanguageModels.LanguageModel[]> => {
+        return await runMapiRequestAsync({
+            logSpinner: logSpinner,
+            logger: logger,
+            func: async () => (await client.listLanguages().toAllPromise()).data.items,
+            action: 'list',
+            type: 'language'
+        });
+    };
+
+    const getAllCollectionsAsync = async (logSpinner: LogSpinnerData): Promise<readonly CollectionModels.Collection[]> => {
+        return await runMapiRequestAsync({
+            logger: logger,
+            logSpinner: logSpinner,
+            func: async () => (await client.listCollections().toPromise()).data.collections,
+            action: 'list',
+            type: 'collection'
+        });
+    };
+
+    const getAllWorkflowsAsync = async (logSpinner: LogSpinnerData): Promise<readonly WorkflowModels.Workflow[]> => {
+        return await runMapiRequestAsync({
+            logger: logger,
+            logSpinner: logSpinner,
+            func: async () => (await client.listWorkflows().toPromise()).data,
+            action: 'list',
+            type: 'workflow'
+        });
+    };
+
+    const getAllTaxonomiesAsync = async (logSpinner: LogSpinnerData): Promise<readonly TaxonomyModels.Taxonomy[]> => {
+        return await runMapiRequestAsync({
+            logger: logger,
+            logSpinner: logSpinner,
+            func: async () => (await client.listTaxonomies().toAllPromise()).data.items,
+            action: 'list',
+            type: 'taxonomy'
+        });
+    };
+
+    const getAllAssetFoldersAsync = async (logSpinner: LogSpinnerData): Promise<readonly AssetFolderModels.AssetFolder[]> => {
+        return await runMapiRequestAsync({
+            logger: logger,
+            logSpinner: logSpinner,
+            func: async () => (await client.listAssetFolders().toPromise()).data.items,
+            action: 'list',
+            type: 'assetFolder'
+        });
+    };
+
+    const getContentTypeElements = (
+        contentType: ContentTypeModels.ContentType,
+        contentTypeSnippets: readonly ContentTypeSnippetModels.ContentTypeSnippet[]
+    ): readonly FlattenedContentTypeElement[] => {
+        return contentType.elements
+            .flatMap((element) => {
+                if (!element.codename || !element.id) {
+                    return undefined;
+                }
+
+                if (element.type === 'guidelines') {
+                    return undefined;
+                }
+
+                if (element.type === 'snippet') {
+                    const snippetElement = element;
+
+                    // replace snippet element with actual elements
+                    const contentTypeSnippet = findRequired(
+                        contentTypeSnippets,
+                        (snippet) => snippet.id === snippetElement.snippet.id,
+                        `Could not find content type snippet for element. This snippet is referenced in type '${chalk.red(
+                            contentType.codename
+                        )}'`
+                    );
+
+                    return contentTypeSnippet.elements.map((snippetElement) => {
+                        if (snippetElement.type === 'guidelines' || snippetElement.type === 'snippet') {
+                            return undefined;
+                        }
+                        if (!snippetElement.codename || !snippetElement.id) {
+                            return undefined;
+                        }
+
+                        const flattenedElement: FlattenedContentTypeElement = {
+                            codename: snippetElement.codename,
+                            type: snippetElement.type,
+                            id: snippetElement.id,
+                            element: snippetElement
+                        };
+
+                        return flattenedElement;
+                    });
+                }
+                const flattenedElement: FlattenedContentTypeElement = {
+                    codename: element.codename,
+                    id: element.id,
+                    type: element.type,
+                    element: element
+                };
+
+                return flattenedElement;
+            })
+            .filter(isNotUndefined);
+    };
+
+    const getFlattenedContentTypesAsync = async (logSpinner: LogSpinnerData): Promise<readonly FlattenedContentType[]> => {
+        const contentTypes = await runMapiRequestAsync({
+            logger: logger,
+            logSpinner: logSpinner,
+            func: async () => (await client.listContentTypes().toAllPromise()).data.items,
+            action: 'list',
+            type: 'contentType'
+        });
+
+        const contentTypeSnippets = await runMapiRequestAsync({
+            logger: logger,
+            logSpinner: logSpinner,
+            func: async () => (await client.listContentTypeSnippets().toAllPromise()).data.items,
+            action: 'list',
+            type: 'contentTypeSnippet'
+        });
+
+        return [
+            ...contentTypes.map((contentType) => {
+                const importType: FlattenedContentType = {
+                    contentTypeCodename: contentType.codename,
+                    contentTypeId: contentType.id,
+                    elements: getContentTypeElements(contentType, contentTypeSnippets)
+                };
+
+                return importType;
+            })
+        ];
+    };
+
+    return {
+        getAllCollectionsAsync,
+        getAllLanguagesAsync,
+        getAllWorkflowsAsync,
+        getAllTaxonomiesAsync,
+        getFlattenedContentTypesAsync,
+        getEnvironmentAsync,
+        getAllAssetFoldersAsync
+    };
+}

package/lib/core/utils/run.utils.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { MapiAction, MapiType } from '../models/core.models.js';
 import { LogMessage, LogSpinnerData, Logger } from '../models/log.models.js';
+import { match } from 'ts-pattern';
 
 export async function runMapiRequestAsync<TResult>(data: {
     readonly logger: Logger;
@@ -10,24 +11,32 @@ export async function runMapiRequestAsync<TResult>(data: {
     readonly func: () => Promise<TResult>;
     readonly itemName?: string;
 }): Promise<TResult> {
-    let logData: LogMessage | undefined;
-
-    if (data.action === 'list') {
-        logData = {
-            message: `Fetching objects of type '${chalk.yellow(data.type)}'`,
-            type: data.action
-        };
-    } else if (data.itemName) {
-        logData = {
-            message: `${data.type} -> ${data.itemName}`,
-            type: data.action
-        };
-    } else {
-        logData = {
-            message: `${data.type}`,
-            type: data.action
-        };
-    }
+    const logData: LogMessage = match(data)
+        .returnType<LogMessage>()
+        .when(
+            (data) => data.action === 'list',
+            (data) => {
+                return {
+                    message: `Fetching objects of type '${chalk.yellow(data.type)}'`,
+                    type: data.action
+                };
+            }
+        )
+        .when(
+            (data) => data.itemName,
+            (data) => {
+                return {
+                    message: `${data.type} -> ${data.itemName}`,
+                    type: data.action
+                };
+            }
+        )
+        .otherwise(() => {
+            return {
+                message: `${data.type}`,
+                type: data.action
+            };
+        });
 
     logSpinnerOrDefault({
         logSpinner: data.logSpinner,

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

@@ -44,7 +44,8 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
                 contentTypes: await mapiUtils.getFlattenedContentTypesAsync(spinnerData),
                 languages: await mapiUtils.getAllLanguagesAsync(spinnerData),
                 workflows: await mapiUtils.getAllWorkflowsAsync(spinnerData),
-                taxonomies: await mapiUtils.getAllTaxonomiesAsync(spinnerData)
+                taxonomies: await mapiUtils.getAllTaxonomiesAsync(spinnerData),
+                assetFolders: await mapiUtils.getAllAssetFoldersAsync(spinnerData)
             };
 
             spinnerData({ type: 'info', message: `Environmental data loaded` });

package/lib/export/export-manager.ts

@@ -1,6 +1,6 @@
 import { ExportContext, ExportConfig, ExportItem } from './export.models.js';
 import chalk from 'chalk';
-import { AssetModels, CollectionModels, ElementModels } from '@kontent-ai/management-sdk';
+import { AssetFolderModels, AssetModels, CollectionModels, ElementModels } from '@kontent-ai/management-sdk';
 import {
     MigrationAsset,
     MigrationItem,
@@ -19,7 +19,8 @@ import {
     findRequired,
     Writeable,
     MigrationItemsSchema,
-    MigrationAssetsSchema
+    MigrationAssetsSchema,
+    MigrationItemVersion
 } from '../core/index.js';
 import { exportTransforms } from '../translation/index.js';
 import { exportContextFetcherAsync } from './context/export-context-fetcher.js';
@@ -45,8 +46,14 @@ export function exportManager(config: ExportConfig) {
                 }
             },
             versions: exportItem.versions.map((version) => {
-                return {
+                return <MigrationItemVersion>{
                     elements: getMigrationElements(context, exportItem.contentType, version.languageVariant.elements),
+                    schedule: {
+                        publish_time: version.languageVariant.schedule.publishTime ?? undefined,
+                        publish_display_timezone: version.languageVariant.schedule.publishDisplayTimezone ?? undefined,
+                        unpublish_display_timezone: version.languageVariant.schedule.unpublishDisplayTimezone ?? undefined,
+                        unpublish_time: version.languageVariant.schedule.unpublishTime ?? undefined
+                    },
                     workflow_step: {
                         codename: version.workflowStepCodename
                     }
@@ -182,6 +189,9 @@ export function exportManager(config: ExportConfig) {
                 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',
@@ -196,6 +206,7 @@ export function exportManager(config: ExportConfig) {
                     codename: asset.codename,
                     binaryData: 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,

package/lib/export/export.models.ts

@@ -18,13 +18,15 @@ import {
     LanguageModels,
     TaxonomyModels,
     ManagementClient,
-    SharedModels
+    SharedModels,
+    AssetFolderModels
 } from '@kontent-ai/management-sdk';
 
 export interface ExportContextEnvironmentData {
     readonly languages: readonly Readonly<LanguageModels.LanguageModel>[];
     readonly contentTypes: readonly Readonly<FlattenedContentType>[];
     readonly collections: readonly Readonly<CollectionModels.Collection>[];
+    readonly assetFolders: readonly Readonly<AssetFolderModels.AssetFolder>[];
     readonly workflows: readonly Readonly<WorkflowModels.Workflow>[];
     readonly taxonomies: readonly Readonly<TaxonomyModels.Taxonomy>[];
 }

package/lib/import/comparers/asset-comparer.ts

@@ -1,4 +1,4 @@
-import { AssetModels, CollectionModels, LanguageModels } from '@kontent-ai/management-sdk';
+import { AssetFolderModels, AssetModels, CollectionModels, LanguageModels } from '@kontent-ai/management-sdk';
 import { MigrationAsset, MigrationAssetDescription, findRequired, geSizeInBytes } from '../../core/index.js';
 import deepEqual from 'deep-equal';
 
@@ -7,35 +7,22 @@ export function shouldUpdateAsset(data: {
     readonly targetAsset: Readonly<AssetModels.Asset>;
     readonly collections: readonly Readonly<CollectionModels.Collection>[];
     readonly languages: readonly Readonly<LanguageModels.LanguageModel>[];
+    readonly assetFolders: readonly Readonly<AssetFolderModels.AssetFolder>[];
 }): boolean {
-    if (!isInSameCollection(data)) {
-        return true;
-    }
-
-    if (!areDescriptionsIdentical(data)) {
-        return true;
-    }
-
-    if (!isTitleIdentical(data)) {
-        return true;
-    }
-
-    if (!isBinaryFileIdentical(data)) {
-        return true;
-    }
-
-    return false;
+    return (
+        !isInSameCollection(data) ||
+        !areDescriptionsIdentical(data) ||
+        !isTitleIdentical(data) ||
+        !isFolderIdentical(data) ||
+        !isBinaryFileIdentical(data)
+    );
 }
 
 export function shouldReplaceBinaryFile(data: {
     readonly migrationAsset: MigrationAsset;
     readonly targetAsset: Readonly<AssetModels.Asset>;
 }): boolean {
-    if (!isBinaryFileIdentical(data)) {
-        return true;
-    }
-
-    return false;
+    return !isBinaryFileIdentical(data);
 }
 
 function isBinaryFileIdentical(data: {
@@ -51,10 +38,15 @@ function isBinaryFileIdentical(data: {
     return sourceFileSize === targetFileSize && sourceFilename === targetFilename;
 }
 
-function isTitleIdentical(data: {
+function isFolderIdentical(data: {
     readonly migrationAsset: MigrationAsset;
     readonly targetAsset: Readonly<AssetModels.Asset>;
+    readonly assetFolders: readonly Readonly<AssetFolderModels.AssetFolder>[];
 }): boolean {
+    return data.assetFolders.find((m) => m.id === data.targetAsset.folder?.id)?.codename === data.migrationAsset.folder?.codename;
+}
+
+function isTitleIdentical(data: { readonly migrationAsset: MigrationAsset; readonly targetAsset: Readonly<AssetModels.Asset> }): boolean {
     const sourceTitle = data.migrationAsset.title?.length ? data.migrationAsset.title : undefined;
     const targetTitle = data.targetAsset.title?.length ? data.targetAsset.title : undefined;