@kontent-ai/migration-toolkit 2.9.1 → 3.0.0-1

package/lib/core/helpers/workflow-helper.ts

@@ -1,202 +1,207 @@
-import type { WorkflowContracts, WorkflowModels } from '@kontent-ai/management-sdk';
-import chalk from 'chalk';
-import { findRequired } from '../utils/array.utils.js';
+import type { WorkflowContracts, WorkflowModels } from "@kontent-ai/management-sdk";
+import chalk from "chalk";
+import { MigrationToolkitError } from "../models/error.models.js";
+import { findRequired } from "../utils/array.utils.js";
 
 export type WorkflowStep = {
-    readonly codename: string;
-    readonly id: string;
-    readonly transitionsTo: readonly TransitionTo[];
+	readonly codename: string;
+	readonly id: string;
+	readonly transitionsTo: readonly TransitionTo[];
 };
 
 export type ShortestPathResult = {
-    readonly stepCodename: string;
+	readonly stepCodename: string;
 };
 
 type WorkflowMatcher = {
-    readonly match: (workflow: Readonly<WorkflowModels.Workflow>, index: number) => boolean;
-    readonly errorMessage: string;
+	readonly match: (workflow: Readonly<WorkflowModels.Workflow>, index: number) => boolean;
+	readonly errorMessage: string;
 };
 type StepMatcher = {
-    readonly match: (step: WorkflowStep, index: number) => boolean;
-    readonly errorMessage: string;
+	readonly match: (step: WorkflowStep, index: number) => boolean;
+	readonly errorMessage: string;
 };
 
 type TransitionTo = {
-    readonly codename: string;
-    readonly id: string;
+	readonly codename: string;
+	readonly id: string;
 };
 
 export function workflowHelper(workflows: readonly Readonly<WorkflowModels.Workflow>[]) {
-    const mapContractToWorkflowSteps = (
-        workflow: Readonly<WorkflowModels.Workflow>,
-        stepsContract: readonly Readonly<WorkflowContracts.IWorkflowStepNewContract>[]
-    ): readonly WorkflowStep[] => {
-        const allStepsContracts = [...workflow.steps, workflow.archivedStep, workflow.publishedStep, workflow.scheduledStep];
-
-        return stepsContract.map<WorkflowStep>((m) => {
-            return {
-                codename: m.codename,
-                id: m.id,
-                transitionsTo: m.transitions_to.map((transitionTo) => {
-                    const transitionStep = allStepsContracts.find((step) => step.id === transitionTo.step.id);
-
-                    if (!transitionStep) {
-                        throw Error(`Could not find transition step with id '${transitionTo.step.id}' in workflow '${workflow.codename}'`);
-                    }
-
-                    return {
-                        codename: transitionStep.codename,
-                        id: transitionStep.id
-                    };
-                })
-            };
-        });
-    };
-
-    const getWorkflowStep = (workflow: Readonly<WorkflowModels.Workflow>, stepMatcher: StepMatcher): WorkflowStep => {
-        const workflowSteps: readonly WorkflowStep[] = [
-            ...mapContractToWorkflowSteps(workflow, workflow.steps),
-            {
-                codename: workflow.archivedStep.codename,
-                id: workflow.archivedStep.id,
-                transitionsTo: []
-            },
-            {
-                codename: workflow.publishedStep.codename,
-                id: workflow.publishedStep.id,
-                transitionsTo: []
-            },
-            {
-                codename: workflow.scheduledStep.codename,
-                id: workflow.scheduledStep.id,
-                transitionsTo: []
-            }
-        ];
-
-        return findRequired(workflowSteps, stepMatcher.match, stepMatcher.errorMessage);
-    };
-
-    const getWorkflow = (workflowMatcher: WorkflowMatcher): Readonly<WorkflowModels.Workflow> => {
-        return findRequired(workflows, workflowMatcher.match, workflowMatcher.errorMessage);
-    };
-
-    const getWorkflowByCodename = (workflowCodename: string): Readonly<WorkflowModels.Workflow> => {
-        return getWorkflow({
-            errorMessage: [
-                `Workflow with codename '${chalk.red(workflowCodename)}' does not exist in target project`,
-                `Available workflows are (${workflows.length}): ${workflows.map((m) => chalk.cyan(m.codename)).join(', ')}`
-            ].join(', '),
-            match: (workflow) => workflow.codename.toLowerCase() === workflowCodename.toLowerCase()
-        });
-    };
-
-    const getWorkflowStepByCodename = (workflow: Readonly<WorkflowModels.Workflow>, stepCodename: string): WorkflowStep => {
-        return getWorkflowStep(workflow, {
-            errorMessage: [
-                `Workflow step with codename '${chalk.red(stepCodename)}' does not exist in target project`,
-                `Steps in workflow '${chalk.yellow(workflow.codename)}' are (${workflow.steps.length}): ${workflow.steps
-                    .map((m) => chalk.cyan(m.codename))
-                    .join(', ')}`
-            ].join(', '),
-            match: (step) => step.codename.toLowerCase() === stepCodename.toLowerCase()
-        });
-    };
-
-    const getWorkflowStepById = (workflow: Readonly<WorkflowModels.Workflow>, stepId: string): WorkflowStep => {
-        return getWorkflowStep(workflow, {
-            errorMessage: [
-                `Workflow step with codename '${chalk.red(stepId)}' does not exist in target project`,
-                `Steps in workflow '${chalk.yellow(workflow.codename)}' are (${workflow.steps.length}): ${workflow.steps
-                    .map((m) => chalk.cyan(m.id))
-                    .join(', ')}`
-            ].join(', '),
-            match: (step) => step.id.toLowerCase() === stepId.toLowerCase()
-        });
-    };
-
-    const getWorkflowAndStep = (data: {
-        readonly workflowMatcher: WorkflowMatcher;
-        readonly stepMatcher: StepMatcher;
-    }): { step: WorkflowStep; workflow: Readonly<WorkflowModels.Workflow> } => {
-        const workflow = getWorkflow(data.workflowMatcher);
-        return {
-            workflow,
-            step: getWorkflowStep(workflow, data.stepMatcher)
-        };
-    };
-
-    const getWorkflowAndStepByCodenames = (data: {
-        readonly workflowCodename: string;
-        readonly stepCodename: string;
-    }): { step: WorkflowStep; workflow: Readonly<WorkflowModels.Workflow> } => {
-        const workflow = getWorkflowByCodename(data.workflowCodename);
-        return {
-            workflow,
-            step: getWorkflowStepByCodename(workflow, data.stepCodename)
-        };
-    };
-
-    const findShortestPathBetweenSteps = (
-        workflow: WorkflowModels.Workflow,
-        startStep: WorkflowStep,
-        endStep: WorkflowStep
-    ): ReadonlyArray<ShortestPathResult> => {
-        type Node = Readonly<{ parent: null | Node; step: WorkflowStep }>;
-        let deque: Array<Node> = [{ parent: null, step: startStep }];
-
-        const getResult = (node: Node): ReadonlyArray<ShortestPathResult> =>
-            node.parent === null ? [] : [...getResult(node.parent), { stepCodename: node.step.codename }];
-
-        while (deque.length !== 0) {
-            const node = deque.shift() as Node;
-
-            if (node.step.codename === endStep.codename) {
-                return getResult(node);
-            }
-
-            const newNodes = node.step.transitionsTo
-                .filter((s) => deque.find((n) => n.step.codename === s.codename) === undefined)
-                .map((t) => ({
-                    parent: node,
-                    step: getWorkflowStepByCodename(workflow, t.codename)
-                }));
-
-            deque = deque.concat(newNodes);
-        }
-
-        throw new Error(
-            `Could not find the path from step (codename: ${startStep.codename}) to step (codename: ${endStep.codename}) in workflow (codename: ${workflow.codename})`
-        );
-    };
-
-    const isPublishedStepByCodename = (stepCodename: string): boolean => {
-        return workflows.find((workflow) => workflow.publishedStep.codename === stepCodename) ? true : false;
-    };
-
-    const isArchivedStepByCodename = (stepCodename: string): boolean => {
-        return workflows.find((workflow) => workflow.archivedStep.codename === stepCodename) ? true : false;
-    };
-
-    const isScheduledStepByCodename = (stepCodename: string): boolean => {
-        return workflows.find((workflow) => workflow.scheduledStep.codename === stepCodename) ? true : false;
-    };
-
-    const isPublishedStepById = (stepId: string): boolean => {
-        return workflows.find((workflow) => workflow.publishedStep.id === stepId) ? true : false;
-    };
-
-    return {
-        getWorkflowByCodename,
-        getWorkflowStepByCodename,
-        getWorkflowAndStepByCodenames,
-        getWorkflowStepById,
-        getWorkflowStep,
-        getWorkflowAndStep,
-        getWorkflow,
-        isPublishedStepByCodename,
-        isArchivedStepByCodename,
-        isScheduledStepByCodename,
-        isPublishedStepById,
-        findShortestPathBetweenSteps
-    };
+	const mapContractToWorkflowSteps = (
+		workflow: Readonly<WorkflowModels.Workflow>,
+		stepsContract: readonly Readonly<WorkflowContracts.IWorkflowStepNewContract>[],
+	): readonly WorkflowStep[] => {
+		const allStepsContracts = [...workflow.steps, workflow.archivedStep, workflow.publishedStep, workflow.scheduledStep];
+
+		return stepsContract.map<WorkflowStep>((m) => {
+			return {
+				codename: m.codename,
+				id: m.id,
+				transitionsTo: m.transitions_to.map((transitionTo) => {
+					const transitionStep = allStepsContracts.find((step) => step.id === transitionTo.step.id);
+
+					if (!transitionStep) {
+						throw new MigrationToolkitError(
+							"missingWorkflowStep",
+							`Could not find transition step with id '${transitionTo.step.id}' in workflow '${workflow.codename}'`,
+						);
+					}
+
+					return {
+						codename: transitionStep.codename,
+						id: transitionStep.id,
+					};
+				}),
+			};
+		});
+	};
+
+	const getWorkflowStep = (workflow: Readonly<WorkflowModels.Workflow>, stepMatcher: StepMatcher): WorkflowStep => {
+		const workflowSteps: readonly WorkflowStep[] = [
+			...mapContractToWorkflowSteps(workflow, workflow.steps),
+			{
+				codename: workflow.archivedStep.codename,
+				id: workflow.archivedStep.id,
+				transitionsTo: [],
+			},
+			{
+				codename: workflow.publishedStep.codename,
+				id: workflow.publishedStep.id,
+				transitionsTo: [],
+			},
+			{
+				codename: workflow.scheduledStep.codename,
+				id: workflow.scheduledStep.id,
+				transitionsTo: [],
+			},
+		];
+
+		return findRequired(workflowSteps, stepMatcher.match, stepMatcher.errorMessage);
+	};
+
+	const getWorkflow = (workflowMatcher: WorkflowMatcher): Readonly<WorkflowModels.Workflow> => {
+		return findRequired(workflows, workflowMatcher.match, workflowMatcher.errorMessage);
+	};
+
+	const getWorkflowByCodename = (workflowCodename: string): Readonly<WorkflowModels.Workflow> => {
+		return getWorkflow({
+			errorMessage: [
+				`Workflow with codename '${chalk.red(workflowCodename)}' does not exist in target project`,
+				`Available workflows are (${workflows.length}): ${workflows.map((m) => chalk.cyan(m.codename)).join(", ")}`,
+			].join(", "),
+			match: (workflow) => workflow.codename.toLowerCase() === workflowCodename.toLowerCase(),
+		});
+	};
+
+	const getWorkflowStepByCodename = (workflow: Readonly<WorkflowModels.Workflow>, stepCodename: string): WorkflowStep => {
+		return getWorkflowStep(workflow, {
+			errorMessage: [
+				`Workflow step with codename '${chalk.red(stepCodename)}' does not exist in target project`,
+				`Steps in workflow '${chalk.yellow(workflow.codename)}' are (${workflow.steps.length}): ${workflow.steps
+					.map((m) => chalk.cyan(m.codename))
+					.join(", ")}`,
+			].join(", "),
+			match: (step) => step.codename.toLowerCase() === stepCodename.toLowerCase(),
+		});
+	};
+
+	const getWorkflowStepById = (workflow: Readonly<WorkflowModels.Workflow>, stepId: string): WorkflowStep => {
+		return getWorkflowStep(workflow, {
+			errorMessage: [
+				`Workflow step with codename '${chalk.red(stepId)}' does not exist in target project`,
+				`Steps in workflow '${chalk.yellow(workflow.codename)}' are (${workflow.steps.length}): ${workflow.steps
+					.map((m) => chalk.cyan(m.id))
+					.join(", ")}`,
+			].join(", "),
+			match: (step) => step.id.toLowerCase() === stepId.toLowerCase(),
+		});
+	};
+
+	const getWorkflowAndStep = (data: {
+		readonly workflowMatcher: WorkflowMatcher;
+		readonly stepMatcher: StepMatcher;
+	}): { step: WorkflowStep; workflow: Readonly<WorkflowModels.Workflow> } => {
+		const workflow = getWorkflow(data.workflowMatcher);
+		return {
+			workflow,
+			step: getWorkflowStep(workflow, data.stepMatcher),
+		};
+	};
+
+	const getWorkflowAndStepByCodenames = (data: {
+		readonly workflowCodename: string;
+		readonly stepCodename: string;
+	}): { step: WorkflowStep; workflow: Readonly<WorkflowModels.Workflow> } => {
+		const workflow = getWorkflowByCodename(data.workflowCodename);
+		return {
+			workflow,
+			step: getWorkflowStepByCodename(workflow, data.stepCodename),
+		};
+	};
+
+	const findShortestPathBetweenSteps = (
+		workflow: WorkflowModels.Workflow,
+		startStep: WorkflowStep,
+		endStep: WorkflowStep,
+	): ReadonlyArray<ShortestPathResult> => {
+		type Node = Readonly<{ parent: null | Node; step: WorkflowStep }>;
+		let deque: Array<Node> = [{ parent: null, step: startStep }];
+
+		const getResult = (node: Node): ReadonlyArray<ShortestPathResult> =>
+			node.parent === null ? [] : [...getResult(node.parent), { stepCodename: node.step.codename }];
+
+		while (deque.length !== 0) {
+			const node = deque.shift() as Node;
+
+			if (node.step.codename === endStep.codename) {
+				return getResult(node);
+			}
+
+			const newNodes = node.step.transitionsTo
+				// eslint-disable-next-line @typescript-eslint/no-loop-func
+				.filter((s) => deque.find((n) => n.step.codename === s.codename) === undefined)
+				.map((t) => ({
+					parent: node,
+					step: getWorkflowStepByCodename(workflow, t.codename),
+				}));
+
+			deque = deque.concat(newNodes);
+		}
+
+		throw new Error(
+			`Could not find the path from step (codename: ${startStep.codename}) to step (codename: ${endStep.codename}) in workflow (codename: ${workflow.codename})`,
+		);
+	};
+
+	const isPublishedStepByCodename = (stepCodename: string): boolean => {
+		return workflows.some((workflow) => workflow.publishedStep.codename === stepCodename);
+	};
+
+	const isArchivedStepByCodename = (stepCodename: string): boolean => {
+		return workflows.some((workflow) => workflow.archivedStep.codename === stepCodename);
+	};
+
+	const isScheduledStepByCodename = (stepCodename: string): boolean => {
+		return workflows.some((workflow) => workflow.scheduledStep.codename === stepCodename);
+	};
+
+	const isPublishedStepById = (stepId: string): boolean => {
+		return workflows.some((workflow) => workflow.publishedStep.id === stepId);
+	};
+
+	return {
+		getWorkflowByCodename,
+		getWorkflowStepByCodename,
+		getWorkflowAndStepByCodenames,
+		getWorkflowStepById,
+		getWorkflowStep,
+		getWorkflowAndStep,
+		getWorkflow,
+		isPublishedStepByCodename,
+		isArchivedStepByCodename,
+		isScheduledStepByCodename,
+		isPublishedStepById,
+		findShortestPathBetweenSteps,
+	};
 }

package/lib/core/logs/loggers.ts

@@ -1,72 +1,72 @@
-import type { ChalkInstance } from 'chalk';
-import chalk from 'chalk';
-import { match, P } from 'ts-pattern';
-import type { Logger, LogSpinnerMessage } from '../models/log.models.js';
-import { getCurrentEnvironment } from '../utils/global.utils.js';
+import type { ChalkInstance } from "chalk";
+import chalk from "chalk";
+import { match, P } from "ts-pattern";
+import type { Logger, LogSpinnerMessage } from "../models/log.models.js";
+import { getCurrentEnvironment } from "../utils/global.utils.js";
 
 const originalWarn = console.warn;
 
 export function getDefaultLogger(): Logger {
-    return match(getCurrentEnvironment())
-        .with('node', () => defaultNodeLogger)
-        .with('browser', () => defaultBrowserLogger)
-        .exhaustive();
+	return match(getCurrentEnvironment())
+		.with("node", () => defaultNodeLogger)
+		.with("browser", () => defaultBrowserLogger)
+		.exhaustive();
 }
 
 const defaultNodeLogger: Logger = {
-    log: (data) => console.log(getLogDataMessage(data)),
-    logWithSpinnerAsync: async (func) => {
-        const ora = await import('ora');
+	log: (data) => console.log(getLogDataMessage(data)),
+	logWithSpinnerAsync: async (func) => {
+		const ora = await import("ora");
 
-        return await ora.oraPromise(async (spinner) => {
-            // patch global console to prevent disrupting ora instance
-            // this often happens when JS SDK logs console.warn for
-            // retried requests. Patching this ensures the flow is uninterrupted
-            global.console.warn = (m) => {
-                if (m) {
-                    spinner.text = (m as unknown)?.toString() ?? 'Invalid warn value';
-                }
-            };
+		return await ora.oraPromise(async (spinner) => {
+			// patch global console to prevent disrupting ora instance
+			// this often happens when JS SDK logs console.warn for
+			// retried requests. Patching this ensures the flow is uninterrupted
+			global.console.warn = (m) => {
+				if (m) {
+					spinner.text = (m as unknown)?.toString() ?? "Invalid warn value";
+				}
+			};
 
-            const result = await func((data) => {
-                // remember last used prefix. This is useful as we don't have to pass prefix to every single function
-                // calling the spinner
-                if (data.prefix) {
-                    spinner.prefixText = data.prefix ?? '';
-                }
-                spinner.text = getLogDataMessage(data);
-            });
+			const result = await func((data) => {
+				// remember last used prefix. This is useful as we don't have to pass prefix to every single function
+				// calling the spinner
+				if (data.prefix) {
+					spinner.prefixText = data.prefix ?? "";
+				}
+				spinner.text = getLogDataMessage(data);
+			});
 
-            // restore original warn
-            global.console.warn = originalWarn;
+			// restore original warn
+			global.console.warn = originalWarn;
 
-            return result;
-        }, {});
-    }
+			return result;
+		}, {});
+	},
 };
 
 const defaultBrowserLogger: Logger = {
-    log: (data) => console.log(getLogDataMessage(data)),
-    logWithSpinnerAsync: async (func) => {
-        return await func((data) => {
-            const prefix = data.prefix ? `${data.prefix}: ` : '';
-            console.log(`${prefix}${getLogDataMessage(data)}`);
-        });
-    }
+	log: (data) => console.log(getLogDataMessage(data)),
+	logWithSpinnerAsync: async (func) => {
+		return await func((data) => {
+			const prefix = data.prefix ? `${data.prefix}: ` : "";
+			console.log(`${prefix}${getLogDataMessage(data)}`);
+		});
+	},
 };
 
 function getLogDataMessage(data: LogSpinnerMessage): string {
-    if (!data.type) {
-        return data.message;
-    }
+	if (!data.type) {
+		return data.message;
+	}
 
-    const color = match(data.type)
-        .returnType<ChalkInstance>()
-        .with('info', () => chalk.cyan)
-        .with(P.union('error', 'errorData', 'warning', 'cancel'), () => chalk.red)
-        .with('completed', () => chalk.green)
-        .with('skip', () => chalk.gray)
-        .otherwise(() => chalk.yellow);
+	const color = match(data.type)
+		.returnType<ChalkInstance>()
+		.with("info", () => chalk.cyan)
+		.with(P.union("error", "errorData", "warning", "cancel"), () => chalk.red)
+		.with("completed", () => chalk.green)
+		.with("skip", () => chalk.gray)
+		.otherwise(() => chalk.yellow);
 
-    return `${color(data.type)}: ${data.message}`;
+	return `${color(data.type)}: ${data.message}`;
 }