@kontent-ai/migration-toolkit 1.0.1 → 1.1.0

package/lib/core/models/migration.models.ts

@@ -1,165 +1,62 @@
-export type MigrationElementType =
-    | 'text'
-    | 'rich_text'
-    | 'number'
-    | 'multiple_choice'
-    | 'date_time'
-    | 'asset'
-    | 'modular_content'
-    | 'taxonomy'
-    | 'url_slug'
-    | 'custom'
-    | 'subpages';
-
-export type MigrationUrlSlugMode = 'autogenerated' | 'custom';
-
-export interface MigrationRichTextElementValue {
-    value: string;
-    components: readonly MigrationComponent[];
-}
-
-export interface MigrationUrlSlugElementValue {
-    value: string | undefined;
-    mode: MigrationUrlSlugMode;
-}
-
-export interface MigrationComponent {
-    system: {
-        id: string;
-        type: MigrationReference;
-    };
-    elements: MigrationElements;
-}
-
-export type MigrationElementValue =
-    | string
-    | undefined
-    | MigrationReference[]
-    | number
-    | MigrationRichTextElementValue
-    | MigrationUrlSlugElementValue;
-
-export interface MigrationElement<
-    TElementType extends MigrationElementType = MigrationElementType,
-    TValue extends MigrationElementValue = MigrationElementValue
-> {
-    /**
-     * Value of the element
-     */
-    readonly value: TValue;
-
-    /**
-     * Type of the element
-     */
-    readonly type: TElementType;
-}
+import { z } from 'zod';
+import {
+    MigrationComponentSchema,
+    MigrationElementTypeSchema,
+    MigrationElementValueSchema,
+    MigrationReferenceSchema,
+    MigrationUrlSlugElementValueSchema,
+    MigrationUrlSlugModeSchema,
+    MigrationRichTextElementValueSchema,
+    MigrationElementSchema,
+    MigrationElementsSchema,
+    MigrationAssetDescriptionSchema,
+    MigrationDataSchema,
+    MigrationAssetSchema,
+    BaseMigrationItemSchema,
+    BaseMigrationItemVersionSchema
+} from './migration.schema.js';
 
 export namespace MigrationElementModels {
-    export interface TextElement extends MigrationElement<'text', string | undefined> {}
-    export interface NumberElement extends MigrationElement<'number', number | undefined> {}
-    export interface RichTextElement extends MigrationElement<'rich_text', MigrationRichTextElementValue | undefined> {}
-    export interface MultipleChoiceElement
-        extends MigrationElement<'multiple_choice', MigrationReference[] | undefined> {}
-    export interface DateTimeElement extends MigrationElement<'date_time', string | undefined> {}
-    export interface AssetElement extends MigrationElement<'asset', MigrationReference[] | undefined> {}
-    export interface LinkedItemsElement extends MigrationElement<'modular_content', MigrationReference[] | undefined> {}
-    export interface TaxonomyElement extends MigrationElement<'taxonomy', MigrationReference[] | undefined> {}
-    export interface UrlSlugElement extends MigrationElement<'url_slug', MigrationUrlSlugElementValue | undefined> {}
-    export interface CustomElement extends MigrationElement<'custom', string | undefined> {}
-    export interface SubpagesElement extends MigrationElement<'subpages', MigrationReference[] | undefined> {}
-}
-
-export interface MigrationElements {
-    [elementCodename: string]: MigrationElement;
-}
+    type MigrationElementDef<
+        TElementType extends MigrationElementType = MigrationElementType,
+        TValue extends MigrationElementValue = MigrationElementValue
+    > = {
+        readonly value: TValue;
+        readonly type: TElementType;
+    };
 
-export interface MigrationItemVersion<TElements extends MigrationElements = MigrationElements> {
+    export type TextElement = MigrationElementDef<'text', string | undefined>;
+    export type NumberElement = MigrationElementDef<'number', number | undefined>;
+    export type RichTextElement = MigrationElementDef<'rich_text', MigrationRichTextElementValue | undefined>;
+    export type MultipleChoiceElement = MigrationElementDef<'multiple_choice', MigrationReference[] | undefined>;
+    export type DateTimeElement = MigrationElementDef<'date_time', string | undefined>;
+    export type AssetElement = MigrationElementDef<'asset', MigrationReference[] | undefined>;
+    export type LinkedItemsElement = MigrationElementDef<'modular_content', MigrationReference[] | undefined>;
+    export type TaxonomyElement = MigrationElementDef<'taxonomy', MigrationReference[] | undefined>;
+    export type UrlSlugElement = MigrationElementDef<'url_slug', MigrationUrlSlugElementValue | undefined>;
+    export type CustomElement = MigrationElementDef<'custom', string | undefined>;
+    export type SubpagesElement = MigrationElementDef<'subpages', MigrationReference[] | undefined>;
+}
+
+export type MigrationReference = z.infer<typeof MigrationReferenceSchema>;
+export type MigrationUrlSlugMode = z.infer<typeof MigrationUrlSlugModeSchema>;
+export type MigrationElementType = z.infer<typeof MigrationElementTypeSchema>;
+export type MigrationUrlSlugElementValue = z.infer<typeof MigrationUrlSlugElementValueSchema>;
+export type MigrationRichTextElementValue = z.infer<typeof MigrationRichTextElementValueSchema>;
+export type MigrationComponent = z.infer<typeof MigrationComponentSchema>;
+export type MigrationElementValue = z.infer<typeof MigrationElementValueSchema>;
+export type MigrationElement = z.infer<typeof MigrationElementSchema>;
+export type MigrationElements = z.infer<typeof MigrationElementsSchema>;
+export type MigrationAssetDescription = z.infer<typeof MigrationAssetDescriptionSchema>;
+export type MigrationAsset = z.infer<typeof MigrationAssetSchema>;
+export type MigrationData = z.infer<typeof MigrationDataSchema>;
+
+export type MigrationItemVersion<TElements extends MigrationElements = MigrationElements> = z.infer<
+    typeof BaseMigrationItemVersionSchema
+> & {
     readonly elements: TElements;
-    readonly workflow_step: MigrationReference;
-}
-
-export interface MigrationItem<TElements extends MigrationElements = MigrationElements> {
-    readonly system: {
-        /**
-         * Codename of the content item
-         */
-        readonly codename: string;
-        /**
-         * Name of the content item
-         */
-        readonly name: string;
-        /**
-         * Language of the language variant
-         */
-        readonly language: MigrationReference;
-        /**
-         * Content type of the item
-         */
-        readonly type: MigrationReference;
-        /**
-         * Collection of the item
-         */
-        readonly collection: MigrationReference;
+};
 
-        /**
-         * Workflow of the item
-         */
-        readonly workflow: MigrationReference;
-    };
+export type MigrationItem<TElements extends MigrationElements = MigrationElements> = z.infer<typeof BaseMigrationItemSchema> & {
     readonly versions: MigrationItemVersion<TElements>[];
-}
-
-export interface MigrationReference {
-    /**
-     * Codename of the referenced object
-     */
-    readonly codename: string;
-}
-
-export interface MigrationAssetDescription {
-    readonly language: MigrationReference;
-    readonly description?: string;
-}
-
-export interface MigrationAsset {
-    /**
-     * Codename of the asset
-     */
-    readonly codename: string;
-    /**
-     * Binary data of the asset
-     */
-    readonly binaryData: Buffer | Blob;
-    /**
-     * Filename of the asset, will be used as a filename in Kontent.ai after importing the asset
-     */
-    readonly filename: string;
-    /**
-     * Title of the asset
-     */
-    readonly title: string;
-
-    /**
-     * Optional
-     * Collection of the asset
-     */
-    readonly collection?: MigrationReference;
-
-    /**
-     * Optional.
-     * Descriptions of the assets
-     */
-    readonly descriptions?: readonly MigrationAssetDescription[];
-}
-
-export interface MigrationData {
-    /**
-     * Array of migration items to process (export / import)
-     */
-    readonly items: readonly MigrationItem[];
-
-    /**
-     * Array of migration assets to process
-     */
-    readonly assets: readonly MigrationAsset[];
-}
+};

package/lib/core/models/migration.schema.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+
+interface Elements {
+    readonly [key: string]: Element;
+}
+
+type UrlSlugMode = 'autogenerated' | 'custom';
+
+type UrlSlugElementValue = {
+    readonly value?: string;
+    readonly mode: UrlSlugMode;
+};
+
+type Reference = { readonly codename: string };
+
+type Component = {
+    readonly system: {
+        readonly id: string;
+        readonly type: Reference;
+    };
+    readonly elements: Elements;
+};
+
+type RichTextElementValue = {
+    readonly value: string;
+    readonly components: Readonly<Component[]>;
+};
+
+type ElementValue = string | undefined | number | Reference[] | RichTextElementValue | UrlSlugElementValue;
+
+type Element = {
+    readonly type: ElementType;
+    readonly value?: ElementValue;
+};
+
+type ElementType =
+    | 'text'
+    | 'rich_text'
+    | 'number'
+    | 'multiple_choice'
+    | 'date_time'
+    | 'asset'
+    | 'modular_content'
+    | 'taxonomy'
+    | 'url_slug'
+    | 'custom'
+    | 'subpages';
+
+export const MigrationUrlSlugModeSchema = z.enum(['autogenerated', 'custom']).readonly();
+export const MigrationElementTypeSchema = z
+    .enum([
+        'text',
+        'rich_text',
+        'number',
+        'multiple_choice',
+        'date_time',
+        'asset',
+        'modular_content',
+        'taxonomy',
+        'url_slug',
+        'custom',
+        'subpages'
+    ])
+    .readonly();
+
+export const MigrationReferenceSchema = z
+    .strictObject({
+        codename: z.string().readonly()
+    })
+    .readonly();
+
+/**
+ * ZodType is needed to be specified here due to the use of 'lazy' & circular dependency between types
+ * Otherwise TS has no way of statically inferring the type
+ */
+export const MigrationElementsSchema: z.ZodReadonly<z.ZodType<Elements>> = z
+    .record(
+        z.string(),
+        z.lazy(() => MigrationElementSchema)
+    )
+    .readonly();
+
+export const MigrationComponentSchema = z
+    .strictObject({
+        system: z.strictObject({
+            id: z.string(),
+            type: MigrationReferenceSchema
+        }),
+        elements: MigrationElementsSchema
+    })
+    .readonly();
+
+export const MigrationUrlSlugElementValueSchema = z
+    .strictObject({
+        value: z.optional(z.string()),
+        mode: MigrationUrlSlugModeSchema
+    })
+    .readonly();
+
+export const MigrationRichTextElementValueSchema = z
+    .strictObject({
+        value: z.string(),
+        components: z.array(MigrationComponentSchema).readonly()
+    })
+    .readonly();
+
+export const MigrationElementValueSchema = z.union([
+    z.string(),
+    z.undefined(),
+    z.number(),
+    z.array(MigrationReferenceSchema),
+    MigrationRichTextElementValueSchema,
+    MigrationUrlSlugElementValueSchema
+]);
+
+export const MigrationElementSchema = z
+    .strictObject({
+        type: MigrationElementTypeSchema,
+        value: MigrationElementValueSchema
+    })
+    .readonly();
+
+export const BaseMigrationItemVersionSchema = z.strictObject({
+    workflow_step: MigrationReferenceSchema
+});
+
+export const MigrationItemVersionSchema = BaseMigrationItemVersionSchema.extend({
+    elements: MigrationElementsSchema
+}).readonly();
+
+export const BaseMigrationItemSchema = z.strictObject({
+    system: z
+        .strictObject({
+            codename: z.string(),
+            name: z.string(),
+            language: MigrationReferenceSchema,
+            type: MigrationReferenceSchema,
+            collection: MigrationReferenceSchema,
+            workflow: MigrationReferenceSchema
+        })
+        .readonly()
+});
+
+export const MigrationItemSchema = BaseMigrationItemSchema.extend({
+    versions: z.array(MigrationItemVersionSchema)
+}).readonly();
+
+export const MigrationAssetDescriptionSchema = z
+    .strictObject({
+        language: MigrationReferenceSchema,
+        description: z.optional(z.string())
+    })
+    .readonly();
+
+const BaseMigrationAssetSchema = z.strictObject({
+    codename: z.string(),
+    filename: z.string(),
+    title: z.string(),
+    collection: z.optional(MigrationReferenceSchema),
+    descriptions: z.optional(z.array(MigrationAssetDescriptionSchema)).readonly()
+});
+
+export const MigrationAssetSchema = BaseMigrationAssetSchema.extend({
+    binaryData: z.union([z.instanceof(Buffer), z.instanceof(Blob)])
+}).readonly();
+
+export const ZipMigrationAssetSchema = BaseMigrationAssetSchema.extend({
+    _zipFilename: z.string()
+}).readonly();
+
+export const MigrationAssetsSchema = z.array(MigrationAssetSchema).readonly();
+export const ZipMigrationAssetsSchema = z.array(ZipMigrationAssetSchema).readonly();
+export const MigrationItemsSchema = z.array(MigrationItemSchema).readonly();
+
+export const MigrationDataSchema = z
+    .strictObject({
+        items: MigrationItemsSchema,
+        assets: MigrationAssetsSchema
+    })
+    .readonly();

package/lib/core/utils/confirm.utils.ts

@@ -23,7 +23,7 @@ export async function confirmExportAsync(data: {
         data.dataToExport.itemsCount
     )}' content ${getItemsPluralText(data.dataToExport.itemsCount)} from ${chalk.yellow(
         environment.name
-    )} (${chalk.yellow(environment.environment)}?`;
+    )} (${chalk.magenta(environment.environment)})?`;
 
     await confirmAsync({
         force: data.force,
@@ -65,9 +65,9 @@ export async function confirmMigrateAsync(data: {
 
     const text: string = `Are you sure to migrate '${chalk.cyan(data.dataToMigrate.itemsCount)}' ${getItemsPluralText(
         data.dataToMigrate.itemsCount
-    )} from ${chalk.yellow(sourceEnvironment.name)} (${chalk.yellow(
+    )} from ${chalk.yellow(sourceEnvironment.name)} (${chalk.magenta(
         sourceEnvironment.environment
-    )}) to environment ${chalk.yellow(targetEnvironment.name)} (${chalk.yellow(targetEnvironment.environment)}) ?`;
+    )}) to environment ${chalk.yellow(targetEnvironment.name)} (${chalk.magenta(targetEnvironment.environment)}) ?`;
 
     await confirmAsync({
         force: data.force,
@@ -91,7 +91,7 @@ export async function confirmImportAsync(data: {
         data.logger
     ).getEnvironmentAsync();
 
-    const text: string = `Are you sure to import data into ${chalk.yellow(environment.name)} (${chalk.yellow(
+    const text: string = `Are you sure to import data into ${chalk.yellow(environment.name)} (${chalk.magenta(
         environment.environment
     )})?`;
 

package/lib/core/utils/error.utils.ts

@@ -1,6 +1,7 @@
 import { SharedModels } from '@kontent-ai/management-sdk';
 import chalk from 'chalk';
 import { ErrorData, OriginalManagementError } from '../models/core.models.js';
+import { ZodError } from 'zod';
 
 export function extractErrorData(error: unknown): ErrorData {
     let isUnknownError: boolean = true;
@@ -10,15 +11,17 @@ export function extractErrorData(error: unknown): ErrorData {
 
     if (error instanceof SharedModels.ContentManagementBaseKontentError) {
         isUnknownError = false;
-        message = `${error.message}`;
-
-        const originalError: OriginalManagementError | undefined = error.originalError as
-            | OriginalManagementError
-            | undefined;
+        const originalError = error.originalError as OriginalManagementError | undefined;
 
         requestUrl = originalError?.response?.config?.url;
         requestData = originalError?.response?.config?.data;
-        message += error.validationErrors.map((m) => m.message).join(', ');
+
+        message = `${error.message}: ${error.validationErrors.map((m) => m.message).join(', ')}`;
+    } else if (error instanceof ZodError) {
+        isUnknownError = false;
+        message = `Found '${chalk.red(error.issues.length)}' parsing errors: \n${error.issues.reduce<string>((current, issue, index) => {
+            return (current += `\n${index + 1}. ${chalk.red(issue.message)} (${chalk.yellow('path')}: ${issue.path.join(',')})`);
+        }, '')}`;
     } else if (error instanceof Error) {
         message = error.message;
     }

package/lib/core/utils/global.utils.ts

@@ -3,6 +3,8 @@ import { ITrackingEventData, getTrackingService } from '@kontent-ai-consulting/t
 import { isBrowser, isNode, isWebWorker } from 'browser-or-node';
 import { EnvContext } from '../models/core.models.js';
 
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+
 export const isNotUndefined = <T>(item: T | undefined): item is T => item !== undefined;
 
 export function formatBytes(bytes: number): string {
@@ -28,9 +30,7 @@ export function getCurrentEnvironment(): EnvContext {
     throw Error(`Invalid current environment. This library can be used in node.js or in browsers.`);
 }
 
-export function getDefaultZipFilename(): string {
-    return `data.zip`;
-}
+export const defaultZipFilename: string = 'data.zip';
 
 export async function executeWithTrackingAsync<TResult>(data: {
     func: () => Promise<TResult extends void ? void : Readonly<TResult>>;

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

@@ -62,10 +62,11 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
         return await runMapiRequestAsync({
             logger: config.logger,
             logSpinner: logSpinner,
-            func: async () =>
-                (
+            func: async () => {
+                return (
                     await config.managementClient.viewContentItem().byItemCodename(sourceItem.itemCodename).toPromise()
-                ).data,
+                ).data;
+            },
             action: 'view',
             type: 'contentItem',
             itemName: `codename -> ${sourceItem.itemCodename}`
@@ -79,14 +80,16 @@ export async function exportContextFetcherAsync(config: DefaultExportContextConf
         return await runMapiRequestAsync({
             logger: config.logger,
             logSpinner: logSpinner,
-            func: async () =>
-                (
+            func: async () => {
+                return (
                     await config.managementClient
                         .viewLanguageVariant()
                         .byItemCodename(sourceItem.itemCodename)
                         .byLanguageCodename(sourceItem.languageCodename)
                         .toPromise()
-                ).data,
+                ).data;
+            },
+
             action: 'view',
             type: 'languageVariant',
             itemName: `codename -> ${sourceItem.itemCodename} -> latest (${sourceItem.languageCodename})`

package/lib/export/export-manager.ts

@@ -16,7 +16,10 @@ import {
     isNotUndefined,
     MigrationElementValue,
     getMigrationManagementClient,
-    findRequired
+    findRequired,
+    Writeable,
+    MigrationItemsSchema,
+    MigrationAssetsSchema
 } from '../core/index.js';
 import { exportTransforms } from '../translation/index.js';
 import { exportContextFetcherAsync } from './context/export-context-fetcher.js';
@@ -61,11 +64,7 @@ export function exportManager(config: ExportConfig) {
         const componentType = context.environmentData.contentTypes.find((m) => m.contentTypeId === component.type.id);
 
         if (!componentType) {
-            throw Error(
-                `Could not find content type with id '${chalk.red(component.type.id)}' for component '${chalk.red(
-                    component.id
-                )}'`
-            );
+            throw Error(`Could not find content type with id '${chalk.red(component.type.id)}' for component '${chalk.red(component.id)}'`);
         }
 
         const migrationItem: MigrationComponent = {
@@ -96,7 +95,7 @@ export function exportManager(config: ExportConfig) {
                 }
                 return 0;
             })
-            .reduce<MigrationElements>((model, typeElement) => {
+            .reduce<Writeable<MigrationElements>>((model, typeElement) => {
                 const itemElement = findRequired(
                     elements,
                     (m) => m.element.id === typeElement.id,
@@ -128,9 +127,7 @@ export function exportManager(config: ExportConfig) {
                 context: data.context,
                 typeElement: data.typeElement,
                 exportElement: {
-                    components: data.exportElement.components.map((component) =>
-                        mapToMigrationComponent(data.context, component)
-                    ),
+                    components: data.exportElement.components.map((component) => mapToMigrationComponent(data.context, component)),
                     value: data.exportElement.value,
                     urlSlugMode: data.exportElement.mode
                 }
@@ -155,9 +152,7 @@ export function exportManager(config: ExportConfig) {
 
     const exportAssetsAsync = async (context: ExportContext): Promise<readonly Readonly<MigrationAsset>[]> => {
         const assets = Array.from(context.referencedData.assetIds)
-            .map<Readonly<AssetModels.Asset> | undefined>(
-                (assetId) => context.getAssetStateInSourceEnvironment(assetId).asset
-            )
+            .map<Readonly<AssetModels.Asset> | undefined>((assetId) => context.getAssetStateInSourceEnvironment(assetId).asset)
             .filter(isNotUndefined);
 
         return await getMigrationAssetsWithBinaryDataAsync(assets, context);
@@ -184,8 +179,9 @@ export function exportManager(config: ExportConfig) {
             },
             items: assets,
             processAsync: async (asset, logSpinner) => {
-                const assetCollection: Readonly<CollectionModels.Collection> | undefined =
-                    context.environmentData.collections.find((m) => m.id === asset.collection?.reference?.id);
+                const assetCollection: Readonly<CollectionModels.Collection> | undefined = context.environmentData.collections.find(
+                    (m) => m.id === asset.collection?.reference?.id
+                );
 
                 logSpinner({
                     type: 'download',
@@ -204,9 +200,9 @@ export function exportManager(config: ExportConfig) {
                         const language = findRequired(
                             context.environmentData.languages,
                             (language) => language.id === description.language.id,
-                            `Could not find language with id '${chalk.red(
-                                description.language.id
-                            )}' requested by asset '${chalk.red(asset.codename)}'`
+                            `Could not find language with id '${chalk.red(description.language.id)}' requested by asset '${chalk.red(
+                                asset.codename
+                            )}'`
                         );
 
                         return {
@@ -234,8 +230,8 @@ export function exportManager(config: ExportConfig) {
             ).getExportContextAsync();
 
             const migrationData: MigrationData = {
-                items: getMigrationItems(exportContext),
-                assets: await exportAssetsAsync(exportContext)
+                items: MigrationItemsSchema.parse(getMigrationItems(exportContext)),
+                assets: MigrationAssetsSchema.parse(await exportAssetsAsync(exportContext))
             };
 
             logger.log({

package/lib/import/import-manager.ts

@@ -11,9 +11,7 @@ export function importManager(config: ImportConfig) {
     const logger: Logger = config.logger ?? getDefaultLogger();
     const targetEnvironmentClient: ManagementClient = getMigrationManagementClient(config);
 
-    const importAssetsAsync = async (
-        importContext: ImportContext
-    ): Promise<Pick<ImportResult, 'editedAssets' | 'uploadedAssets'>> => {
+    const importAssetsAsync = async (importContext: ImportContext): Promise<Pick<ImportResult, 'editedAssets' | 'uploadedAssets'>> => {
         if (!importContext.categorizedImportData.assets.length) {
             logger.log({
                 type: 'info',
@@ -31,9 +29,7 @@ export function importManager(config: ImportConfig) {
             logger: logger
         }).importAsync();
     };
-    const importContentItemsAsync = async (
-        importContext: ImportContext
-    ): Promise<readonly Readonly<ContentItemModels.ContentItem>[]> => {
+    const importContentItemsAsync = async (importContext: ImportContext): Promise<readonly Readonly<ContentItemModels.ContentItem>[]> => {
         if (!importContext.categorizedImportData.contentItems.length) {
             logger.log({
                 type: 'info',

package/lib/metadata.ts

@@ -1,6 +1,6 @@
 
 export const libMetadata = {
 	name: '@kontent-ai/migration-toolkit',
-    timestamp: 'Wed, 10 Jul 2024 11:27:45 GMT',
-    version: '1.0.1'
+    timestamp: 'Tue, 16 Jul 2024 13:30:22 GMT',
+    version: '1.1.0'
 };

package/lib/node/cli/actions/export-action.ts

@@ -1,4 +1,4 @@
-import { confirmExportAsync, getDefaultZipFilename, getDefaultLogger } from '../../../core/index.js';
+import { confirmExportAsync, defaultZipFilename, getDefaultLogger } from '../../../core/index.js';
 import { exportAsync, storeAsync } from '../../../toolkit/index.js';
 import { CliArgumentsFetcher } from '../cli.models.js';
 
@@ -10,7 +10,7 @@ export async function exportActionAsync(cliFetcher: CliArgumentsFetcher): Promis
     const items = cliFetcher.getRequiredArgumentValue('items').split(',');
     const baseUrl = cliFetcher.getOptionalArgumentValue('baseUrl');
     const force = cliFetcher.getBooleanArgumentValue('force', false);
-    const filename = cliFetcher.getOptionalArgumentValue('filename') ?? getDefaultZipFilename();
+    const filename = cliFetcher.getOptionalArgumentValue('filename') ?? defaultZipFilename;
 
     await confirmExportAsync({
         force: force,

package/lib/node/cli/actions/import-action.ts

@@ -1,4 +1,4 @@
-import { confirmImportAsync, getDefaultZipFilename, getDefaultLogger } from '../../../core/index.js';
+import { confirmImportAsync, defaultZipFilename, getDefaultLogger } from '../../../core/index.js';
 import { extractAsync, importAsync } from '../../../toolkit/index.js';
 import { CliArgumentsFetcher } from '../cli.models.js';
 
@@ -8,7 +8,7 @@ export async function importActionAsync(argsFetcher: CliArgumentsFetcher): Promi
     const apiKey = argsFetcher.getRequiredArgumentValue('targetApiKey');
     const baseUrl = argsFetcher.getOptionalArgumentValue('baseUrl');
     const force = argsFetcher.getBooleanArgumentValue('force', false);
-    const filename = argsFetcher.getOptionalArgumentValue('filename') ?? getDefaultZipFilename();
+    const filename = argsFetcher.getOptionalArgumentValue('filename') ?? defaultZipFilename;
 
     await confirmImportAsync({
         force: force,