@slicemachine/manager 0.24.14-alpha.jp-update-cr-links-delete-field-data-flow.12 → 0.24.14-alpha.jp-update-cr-links-rollback.2

package/src/managers/customTypes/CustomTypesManager.ts

@@ -88,11 +88,14 @@ type CustomTypesMachineManagerDeleteCustomTypeReturnType = {
 	errors: (DecodeError | HookError)[];
 };
 
-type CustomTypeFieldUpdatedPaths = {
-	previousPath: string[];
-	newPath: string[];
+type CustomTypesMachineManagerUpdateCustomTypeReturnType = {
+	errors: (DecodeError | HookError)[];
 };
 
+type CustomTypeFieldIdChangedMeta = NonNullable<
+	NonNullable<CustomTypeUpdateHookData["updateMeta"]>["fieldIdChanged"]
+>;
+
 type CrCustomType =
 	| string
 	| { id: string; fields?: readonly CrCustomTypeNestedCr[] };
@@ -190,96 +193,166 @@ export class CustomTypesManager extends BaseManager {
 
 	/**
 	 * Update the Content Relationship API IDs for all existing custom types and
-	 * slices. The change is determined by properties inside the `updated`
+	 * slices. The change is determined by properties inside the `updateMeta`
 	 * property.
 	 */
 	private async updateContentRelationships(
 		args: CustomTypeUpdateHookData,
-	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeUpdateHook>>> {
+	): Promise<
+		OnlyHookErrors<CallHookReturnType<CustomTypeUpdateHook>> & {
+			rollback: () => Promise<void>;
+		}
+	> {
 		assertPluginsInitialized(this.sliceMachinePluginRunner);
 
-		const { model, updates } = args;
+		const { model, updateMeta } = args;
 
-		if (updates) {
-			for (const [previousPathStr, newPathStr] of Object.entries(updates)) {
-				if (previousPathStr !== newPathStr) {
-					const previousPath = [model.id, ...previousPathStr.split(".")];
-					const newPath = [model.id, ...newPathStr.split(".")];
-					const crUpdates: Promise<{ errors: HookError[] }>[] = [];
+		if (updateMeta?.fieldIdChanged) {
+			let { previousPath, newPath } = updateMeta.fieldIdChanged;
 
-					// Find existing content relationships that link to the renamed field
-					// id in any custom type and update them to use the new one.
-					const customTypes = await this.readAllCustomTypes();
+			if (previousPath.join(".") !== newPath.join(".")) {
+				previousPath = [model.id, ...previousPath];
+				newPath = [model.id, ...newPath];
 
-					updateCustomTypeContentRelationships({
-						models: customTypes.models,
-						onUpdate: (model) => {
-							pushIfDefined(
-								crUpdates,
-								this.sliceMachinePluginRunner?.callHook("custom-type:update", {
-									model,
-								}),
-							);
-						},
-						previousPath,
-						newPath,
-					});
+				const crUpdates: {
+					updatePromise: Promise<{ errors: HookError[] }>;
+					rollback: () => void;
+				}[] = [];
+
+				// Find existing content relationships that link to the renamed field id in
+				// any custom type and update them to use the new one.
+				const customTypes = await this.readAllCustomTypes();
 
-					// Find existing slice with content relationships that link to the
-					// renamed field id in all libraries and update them to use the new one.
-					const { libraries } = await this.slices.readAllSliceLibraries();
+				updateCustomTypeContentRelationships({
+					models: customTypes.models,
+					onUpdate: ({ previousModel, model }) => {
+						assertPluginsInitialized(this.sliceMachinePluginRunner);
 
-					for (const library of libraries) {
-						const slices = await this.slices.readAllSlicesForLibrary({
-							libraryID: library.libraryID,
+						crUpdates.push({
+							updatePromise: this.sliceMachinePluginRunner?.callHook(
+								"custom-type:update",
+								{ model },
+							),
+							rollback: () => {
+								this.sliceMachinePluginRunner?.callHook("custom-type:update", {
+									model: previousModel,
+								});
+							},
 						});
+					},
+					previousPath,
+					newPath,
+				});
 
-						updateSharedSliceContentRelationships({
-							models: slices.models,
-							onUpdate: (model) => {
-								pushIfDefined(
-									crUpdates,
+				// Find existing slice with content relationships that link to the renamed
+				// field id in all libraries and update them to use the new one.
+				const { libraries } = await this.slices.readAllSliceLibraries();
+
+				for (const library of libraries) {
+					const slices = await this.slices.readAllSlicesForLibrary({
+						libraryID: library.libraryID,
+					});
+
+					updateSharedSliceContentRelationships({
+						models: slices.models,
+						onUpdate: ({ previousModel, model }) => {
+							assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+							crUpdates.push({
+								updatePromise: this.sliceMachinePluginRunner?.callHook(
+									"slice:update",
+									{ libraryID: library.libraryID, model },
+								),
+								rollback: () => {
 									this.sliceMachinePluginRunner?.callHook("slice:update", {
 										libraryID: library.libraryID,
-										model,
-									}),
-								);
-							},
-							previousPath,
-							newPath,
-						});
-					}
+										model: previousModel,
+									});
+								},
+							});
+						},
+						previousPath,
+						newPath,
+					});
+				}
 
-					// Process all the Content Relationship updates at once.
-					const crUpdatesResult = await Promise.all(crUpdates);
+				// Process all the Content Relationship updates at once.
+				const crUpdatesResult = await Promise.all(
+					crUpdates.map((update) => update.updatePromise),
+				);
 
-					if (crUpdatesResult.some((result) => result.errors.length > 0)) {
-						return {
-							errors: crUpdatesResult.flatMap((result) => result.errors),
-						};
-					}
+				if (crUpdatesResult.some((result) => result.errors.length > 0)) {
+					return {
+						errors: crUpdatesResult.flatMap((result) => result.errors),
+						rollback: async () => {
+							await Promise.all(crUpdates.map((update) => update.rollback()));
+						},
+					};
 				}
 			}
 		}
 
-		return { errors: [] };
+		return { errors: [], rollback: () => Promise.resolve() };
 	}
 
 	async updateCustomType(
 		args: CustomTypeUpdateHookData,
-	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeUpdateHook>>> {
+	): Promise<CustomTypesMachineManagerUpdateCustomTypeReturnType> {
 		assertPluginsInitialized(this.sliceMachinePluginRunner);
+		const { model } = args;
 
-		const hookResult = await this.sliceMachinePluginRunner.callHook(
+		let updateCrPromise: (() => Promise<{ errors: HookError[] }>) | undefined;
+
+		if (args.updateMeta?.fieldIdChanged) {
+			const customTypeRead = await this.readCustomType({ id: model.id });
+
+			if (customTypeRead.errors.length > 0) {
+				return { errors: customTypeRead.errors };
+			}
+			if (!customTypeRead.model) {
+				throw new Error(
+					"Read custom type without errors, but model is undefined.",
+				);
+			}
+
+			const previousCustomType = customTypeRead.model;
+
+			updateCrPromise = async () => {
+				const crUpdateResult = await this.updateContentRelationships(args);
+
+				if (crUpdateResult.errors.length > 0) {
+					// put the previous custom type back
+					await this.sliceMachinePluginRunner?.callHook("custom-type:update", {
+						model: previousCustomType,
+					});
+					// revert the content relationships updates
+					await crUpdateResult.rollback();
+
+					return { errors: crUpdateResult.errors };
+				}
+
+				return { errors: [] };
+			};
+		}
+
+		// Execute the updates
+
+		const customTypeUpdateResult = await this.sliceMachinePluginRunner.callHook(
 			"custom-type:update",
-			args,
+			{ model },
 		);
 
-		if (args.updates) {
-			await this.updateContentRelationships(args);
+		if (customTypeUpdateResult.errors.length > 0) {
+			return { errors: customTypeUpdateResult.errors };
+		}
+
+		const crUpdateResult = await updateCrPromise?.();
+
+		if (crUpdateResult && crUpdateResult.errors.length > 0) {
+			return { errors: crUpdateResult.errors };
 		}
 
-		return { errors: hookResult.errors };
+		return { errors: [] };
 	}
 
 	async renameCustomType(
@@ -495,7 +568,7 @@ const InferSliceResponse = z.object({
 });
 
 function updateCRCustomType(
-	args: { customType: CrCustomType } & CustomTypeFieldUpdatedPaths,
+	args: { customType: CrCustomType } & CustomTypeFieldIdChangedMeta,
 ): CrCustomType {
 	const [previousCustomTypeId, previousFieldId] = args.previousPath;
 	const [newCustomTypeId, newFieldId] = args.newPath;
@@ -596,8 +669,8 @@ function updateCRCustomType(
  */
 function updateFieldContentRelationships<
 	T extends UID | NestableWidget | Group | NestedGroup,
->(args: { field: T } & CustomTypeFieldUpdatedPaths): T {
-	const { field, ...updatedPaths } = args;
+>(args: { field: T } & CustomTypeFieldIdChangedMeta): T {
+	const { field, ...updateMeta } = args;
 	if (
 		field.type !== "Link" ||
 		field.config?.select !== "document" ||
@@ -608,7 +681,7 @@ function updateFieldContentRelationships<
 	}
 
 	const newCustomTypes = field.config.customtypes.map((customType) => {
-		return updateCRCustomType({ customType, ...updatedPaths });
+		return updateCRCustomType({ customType, ...updateMeta });
 	});
 
 	return {
@@ -620,21 +693,25 @@ function updateFieldContentRelationships<
 export function updateCustomTypeContentRelationships(
 	args: {
 		models: { model: CustomType }[];
-		onUpdate: (model: CustomType) => void;
-	} & CustomTypeFieldUpdatedPaths,
+		onUpdate: (model: { previousModel: CustomType; model: CustomType }) => void;
+	} & CustomTypeFieldIdChangedMeta,
 ): void {
-	const { models, onUpdate, ...updatedPaths } = args;
+	const { models, previousPath, newPath, onUpdate } = args;
 
 	for (const { model: customType } of models) {
-		const updatedCustomTypeModel = traverseCustomType({
+		const updatedCustomType = traverseCustomType({
 			customType,
 			onField: ({ field }) => {
-				return updateFieldContentRelationships({ ...updatedPaths, field });
+				return updateFieldContentRelationships({
+					field,
+					previousPath,
+					newPath,
+				});
 			},
 		});
 
-		if (!isEqualModel(customType, updatedCustomTypeModel)) {
-			onUpdate(updatedCustomTypeModel);
+		if (!isEqualModel(customType, updatedCustomType)) {
+			onUpdate({ model: updatedCustomType, previousModel: customType });
 		}
 	}
 }
@@ -642,22 +719,29 @@ export function updateCustomTypeContentRelationships(
 export function updateSharedSliceContentRelationships(
 	args: {
 		models: { model: SharedSlice }[];
-		onUpdate: (model: SharedSlice) => void;
-	} & CustomTypeFieldUpdatedPaths,
+		onUpdate: (model: {
+			previousModel: SharedSlice;
+			model: SharedSlice;
+		}) => void;
+	} & CustomTypeFieldIdChangedMeta,
 ): void {
-	const { models, onUpdate, ...updatedPaths } = args;
+	const { models, previousPath, newPath, onUpdate } = args;
 
 	for (const { model: slice } of models) {
-		const updatedSliceModel = traverseSharedSlice({
+		const updateSlice = traverseSharedSlice({
 			path: ["."],
 			slice,
 			onField: ({ field }) => {
-				return updateFieldContentRelationships({ ...updatedPaths, field });
+				return updateFieldContentRelationships({
+					field,
+					previousPath,
+					newPath,
+				});
 			},
 		});
 
-		if (!isEqualModel(slice, updatedSliceModel)) {
-			onUpdate(updatedSliceModel);
+		if (!isEqualModel(slice, updateSlice)) {
+			onUpdate({ model: updateSlice, previousModel: slice });
 		}
 	}
 }
@@ -676,9 +760,3 @@ function shallowCloneIfObject<T>(value: T): T {
 
 	return value;
 }
-
-function pushIfDefined<T>(array: T[], value: T | undefined) {
-	if (value) {
-		array.push(value);
-	}
-}