@slicemachine/manager 0.24.16-beta.1 → 0.24.16-beta.11

package/src/managers/customTypes/CustomTypesManager.ts

@@ -3,6 +3,7 @@ import * as prismicCustomTypesClient from "@prismicio/custom-types-client";
 import {
 	CustomType,
 	Group,
+	LinkConfig,
 	NestableWidget,
 	NestedGroup,
 	SharedSlice,
@@ -76,6 +77,30 @@ type SliceMachineManagerUpdateCustomTypeMocksConfigArgs = {
 	mocksConfig: Record<string, unknown>;
 };
 
+/** `[field]` or `[group, field]` – path **inside** the Custom Type */
+type PathWithoutCustomType = [string] | [string, string];
+
+type SliceMachineManagerUpdateCustomTypeFieldIdChanged = {
+	/**
+	 * Previous path of the changed field, excluding the custom type id. Can be
+	 * used to identify the field that had an API ID rename (e.g. ["fieldA"] or
+	 * ["groupA", "fieldA"])
+	 */
+	previousPath: PathWithoutCustomType;
+	/**
+	 * New path of the changed field, excluding the custom type id. Can be used to
+	 * identify the field that had an API ID rename (e.g. ["fieldB"] or ["groupA",
+	 * "fieldB"])
+	 */
+	newPath: PathWithoutCustomType;
+};
+
+type SliceMachineManagerUpdateCustomTypeArgs = CustomTypeUpdateHookData & {
+	updateMeta?: {
+		fieldIdChanged?: SliceMachineManagerUpdateCustomTypeFieldIdChanged;
+	};
+};
+
 type SliceMachineManagerUpdateCustomTypeMocksConfigArgsReturnType = {
 	errors: HookError[];
 };
@@ -92,20 +117,15 @@ type CustomTypesMachineManagerUpdateCustomTypeReturnType = {
 	errors: (DecodeError | HookError)[];
 };
 
+/** `[ct, field]` or `[ct, group, field]` – path **with** Custom Type ID */
+type PathWithCustomType = [string, string] | [string, string, string];
+
 type CustomTypeFieldIdChangedMeta = {
-	previousPath: string[];
-	newPath: string[];
+	previousPath: PathWithCustomType;
+	newPath: PathWithCustomType;
 };
 
-type CrCustomType =
-	| string
-	| { id: string; fields?: readonly CrCustomTypeNestedCr[] };
-type CrCustomTypeNestedCr =
-	| string
-	| { id: string; customtypes: readonly CrCustomTypeFieldLeaf[] };
-type CrCustomTypeFieldLeaf =
-	| string
-	| { id: string; fields?: readonly string[] };
+type LinkCustomType = NonNullable<LinkConfig["customtypes"]>[number];
 
 export class CustomTypesManager extends BaseManager {
 	async readCustomTypeLibrary(): Promise<SliceMachineManagerReadCustomTypeLibraryReturnType> {
@@ -198,7 +218,9 @@ export class CustomTypesManager extends BaseManager {
 	 * property.
 	 */
 	private async updateContentRelationships(
-		args: { model: CustomType } & CustomTypeFieldIdChangedMeta,
+		args: {
+			model: CustomType;
+		} & SliceMachineManagerUpdateCustomTypeFieldIdChanged,
 	): Promise<
 		OnlyHookErrors<CallHookReturnType<CustomTypeUpdateHook>> & {
 			rollback?: () => Promise<void>;
@@ -206,12 +228,16 @@ export class CustomTypesManager extends BaseManager {
 	> {
 		assertPluginsInitialized(this.sliceMachinePluginRunner);
 
-		const { model } = args;
-		let { newPath, previousPath } = args;
+		const {
+			model,
+			previousPath: previousFieldPath,
+			newPath: newFieldPath,
+		} = args;
 
-		if (previousPath.join(".") !== newPath.join(".")) {
-			previousPath = [model.id, ...previousPath];
-			newPath = [model.id, ...newPath];
+		if (previousFieldPath.join(".") !== newFieldPath.join(".")) {
+			const { id: ctId } = model;
+			const previousPath: PathWithCustomType = [ctId, ...previousFieldPath];
+			const newPath: PathWithCustomType = [ctId, ...newFieldPath];
 
 			const crUpdates: {
 				updatePromise: Promise<{ errors: HookError[] }>;
@@ -294,7 +320,7 @@ export class CustomTypesManager extends BaseManager {
 	}
 
 	async updateCustomType(
-		args: CustomTypeUpdateHookData,
+		args: SliceMachineManagerUpdateCustomTypeArgs,
 	): Promise<CustomTypesMachineManagerUpdateCustomTypeReturnType> {
 		assertPluginsInitialized(this.sliceMachinePluginRunner);
 		const { model } = args;
@@ -560,99 +586,227 @@ const InferSliceResponse = z.object({
 });
 
 function updateCRCustomType(
-	args: { customType: CrCustomType } & CustomTypeFieldIdChangedMeta,
-): CrCustomType {
-	const [previousCustomTypeId, previousFieldId] = args.previousPath;
-	const [newCustomTypeId, newFieldId] = args.newPath;
+	args: { customType: LinkCustomType } & CustomTypeFieldIdChangedMeta,
+): LinkCustomType {
+	const previousPath = getPathIds(args.previousPath);
+	const newPath = getPathIds(args.newPath);
 
-	if (!previousCustomTypeId || !newCustomTypeId) {
+	if (!previousPath.customTypeId || !newPath.customTypeId) {
 		throw new Error(
-			"Could not find a customtype id in previousPath and/or newPath, which should not be possible.",
+			`Could not find a customtype id in previousPath (${args.previousPath.join(
+				".",
+			)}) and/or newPath (${args.newPath.join(
+				".",
+			)}), which should not be possible.`,
 		);
 	}
 
-	if (!previousFieldId || !newFieldId) {
+	if (!previousPath.fieldId || !newPath.fieldId) {
 		throw new Error(
-			"Could not find a field id in previousPath and/or newPath, which should not be possible.",
+			`Could not find a field id in previousPath (${args.previousPath.join(
+				".",
+			)}) and/or newPath (${args.newPath.join(
+				".",
+			)}), which should not be possible.`,
 		);
 	}
 
 	const customType = shallowCloneIfObject(args.customType);
 
-	if (typeof customType === "string" || !customType.fields) {
+	if (typeof customType === "string") {
+		// Legacy format support, we don't have anything to update here.
 		return customType;
 	}
 
-	const matchedCustomTypeId = customType.id === previousCustomTypeId;
+	const matchedCustomTypeId = customType.id === previousPath.customTypeId;
+
+	return {
+		...customType,
+		fields: customType.fields.map((fieldArg) => {
+			const customTypeField = shallowCloneIfObject(fieldArg);
+
+			// Regular field
+			if (typeof customTypeField === "string") {
+				if (
+					matchedCustomTypeId &&
+					customTypeField === previousPath.fieldId &&
+					customTypeField !== newPath.fieldId
+				) {
+					// The id of the field has changed.
+					return newPath.fieldId;
+				}
 
-	const newFields = customType.fields.map((fieldArg) => {
-		const customTypeField = shallowCloneIfObject(fieldArg);
+				return customTypeField;
+			}
 
-		if (typeof customTypeField === "string") {
 			if (
 				matchedCustomTypeId &&
-				customTypeField === previousFieldId &&
-				customTypeField !== newFieldId
+				customTypeField.id === previousPath.fieldId &&
+				customTypeField.id !== newPath.fieldId
 			) {
-				// We have reached a field id that matches the id that was renamed,
-				// so we update it new one. The field is a string, so return the new
-				// id.
-				return newFieldId;
+				// The id of the field has changed. We don't exit return because there
+				// might be other fields further down in nested custom types or groups
+				// that need to be updated.
+				customTypeField.id = newPath.fieldId;
 			}
 
-			return customTypeField;
-		}
+			// Group field
+			if ("fields" in customTypeField) {
+				if (
+					!previousPath.groupId &&
+					!newPath.groupId &&
+					customTypeField.id === previousPath.fieldId &&
+					customTypeField.id !== newPath.fieldId
+				) {
+					// Only the id of the group has changed. Group id is not defined, so
+					// we can return early.
+					return newPath.fieldId;
+				}
+
+				const matchedGroupId = customTypeField.id === previousPath.groupId;
+
+				if (
+					previousPath.groupId &&
+					newPath.groupId &&
+					matchedGroupId &&
+					customTypeField.id !== newPath.groupId
+				) {
+					// The id of the group field has changed, so we update it. We don't
+					// return because there are group fields that may need to be updated.
+					customTypeField.id = newPath.groupId;
+				}
+
+				return {
+					...customTypeField,
+					fields: customTypeField.fields.map((groupFieldArg) => {
+						const groupField = shallowCloneIfObject(groupFieldArg);
+
+						// Regular field inside a group field
+						if (typeof groupField === "string") {
+							if (
+								matchedGroupId &&
+								groupField === previousPath.fieldId &&
+								groupField !== newPath.fieldId
+							) {
+								// The id of the field inside the group has changed.
+								return newPath.fieldId;
+							}
+
+							return groupField;
+						}
+
+						// Content relationship field inside a group field
+						return {
+							...groupField,
+							fields: updateContentRelationshipFields({
+								customtypes: groupField.customtypes,
+								previousPath,
+								newPath,
+							}),
+						};
+					}),
+				};
+			}
+
+			// Content relationship field
+			return {
+				...customTypeField,
+				customtypes: updateContentRelationshipFields({
+					customtypes: customTypeField.customtypes,
+					previousPath,
+					newPath,
+				}),
+			};
+		}),
+	};
+}
+
+function updateContentRelationshipFields(args: {
+	customtypes: readonly (
+		| string
+		| {
+				id: string;
+				fields: readonly (string | { id: string; fields: readonly string[] })[];
+		  }
+	)[];
+	previousPath: CrUpdatePathIds;
+	newPath: CrUpdatePathIds;
+}) {
+	const { customtypes, previousPath, newPath } = args;
+
+	return customtypes.map((nestedCtArg) => {
+		const nestedCt = shallowCloneIfObject(nestedCtArg);
 
 		if (
-			matchedCustomTypeId &&
-			customTypeField.id === previousFieldId &&
-			customTypeField.id !== newFieldId
+			typeof nestedCt === "string" ||
+			// Since we are entering a new custom type, if the previous id
+			// doesn't match, we can return early, because it's not the
+			// custom type we are looking for.
+			nestedCt.id !== previousPath.customTypeId
 		) {
-			// We have reached a field id that matches the id that was renamed,
-			// so we update it new one.
-			// Since field is not a string, we don't exit, as we might have
-			// something to update further down in customtypes.
-			customTypeField.id = newFieldId;
+			return nestedCt;
 		}
 
 		return {
-			...customTypeField,
-			customtypes: customTypeField.customtypes.map((customTypeArg) => {
-				const nestedCustomType = shallowCloneIfObject(customTypeArg);
+			...nestedCt,
+			fields: nestedCt.fields.map((nestedCtFieldArg) => {
+				const nestedCtField = shallowCloneIfObject(nestedCtFieldArg);
+
+				// Regular field
+				if (typeof nestedCtField === "string") {
+					if (
+						nestedCtField === previousPath.fieldId &&
+						nestedCtField !== newPath.fieldId
+					) {
+						// The id of the field has changed.
+						return newPath.fieldId;
+					}
+
+					return nestedCtField;
+				}
+
+				// Group field
 
 				if (
-					typeof nestedCustomType === "string" ||
-					!nestedCustomType.fields ||
-					// Since we are on the last level, if we don't start matching right
-					// at the custom type id, we can return exit early because it's not
-					// a match.
-					nestedCustomType.id !== previousCustomTypeId
+					nestedCtField.id === previousPath.fieldId &&
+					nestedCtField.id !== newPath.fieldId
 				) {
-					return nestedCustomType;
+					// The id of the field has changed.
+					nestedCtField.id = newPath.fieldId;
 				}
 
-				return {
-					...nestedCustomType,
-					fields: nestedCustomType.fields.map((fieldArg) => {
-						const nestedCustomTypeField = shallowCloneIfObject(fieldArg);
+				// Further down the path, the field can only be a group field. So if we have
+				// no group id defined, no need to continue.
+				if (
+					!previousPath.groupId ||
+					!newPath.groupId ||
+					nestedCtField.id !== previousPath.groupId
+				) {
+					return nestedCtField;
+				}
+
+				if (nestedCtField.id !== newPath.groupId) {
+					// The id of the group has changed.
+					nestedCtField.id = newPath.groupId;
+				}
 
+				return {
+					...nestedCtField,
+					fields: nestedCtField.fields.map((nestedCtGroupFieldId) => {
 						if (
-							nestedCustomTypeField === previousFieldId &&
-							nestedCustomTypeField !== newFieldId
+							nestedCtGroupFieldId === previousPath.fieldId &&
+							nestedCtGroupFieldId !== newPath.fieldId
 						) {
-							// Matches the previous id, so we update it and return because
-							// it's the last level.
-							return newFieldId;
+							// The id of the field inside the group has changed.
+							return newPath.fieldId;
 						}
 
-						return nestedCustomTypeField;
+						return nestedCtGroupFieldId;
 					}),
 				};
 			}),
 		};
 	});
-
-	return { ...customType, fields: newFields };
 }
 
 /**
@@ -673,7 +827,7 @@ function updateFieldContentRelationships<
 	}
 
 	const newCustomTypes = field.config.customtypes.map((customType) => {
-		return updateCRCustomType({ customType, ...updateMeta });
+		return updateCRCustomType({ ...updateMeta, customType });
 	});
 
 	return {
@@ -721,7 +875,7 @@ export function updateSharedSliceContentRelationships(
 
 	for (const { model: slice } of models) {
 		const updateSlice = traverseSharedSlice({
-			path: ["."],
+			path: [],
 			slice,
 			onField: ({ field }) => {
 				return updateFieldContentRelationships({
@@ -738,6 +892,35 @@ export function updateSharedSliceContentRelationships(
 	}
 }
 
+interface CrUpdatePathIds {
+	customTypeId: string;
+	groupId: string | undefined;
+	fieldId: string;
+}
+
+function getPathIds(path: PathWithCustomType): CrUpdatePathIds {
+	if (path.length < 2) {
+		throw new Error(
+			`Unexpected path length ${
+				path.length
+			}. Expected at least 2 segments (got: ${path.join(".")}).`,
+		);
+	}
+
+	const [customTypeId, groupOrFieldId, fieldId] = path;
+
+	return {
+		customTypeId,
+		/**
+		 * Id of a changed group. If it's defined, it means that a group or a field
+		 * inside a group had its API ID renamed. It's defined when the path has a
+		 * third element (e.g. `["customtypeA", "groupA", "fieldA"]`).
+		 */
+		groupId: fieldId ? groupOrFieldId : undefined,
+		fieldId: fieldId || groupOrFieldId,
+	};
+}
+
 function isEqualModel<T extends CustomType | SharedSlice>(
 	modelA: T,
 	modelB: T,

package/src/managers/telemetry/types.ts

@@ -9,7 +9,6 @@ export const SegmentEventType = {
 	command_init_start: "command:init:start",
 	command_init_identify: "command:init:identify",
 	command_init_end: "command:init:end",
-	review: "review",
 	sliceSimulator_open: "slice-simulator:open",
 	sliceSimulator_isNotRunning: "slice-simulator:is-not-running",
 	pageView: "page-view",
@@ -52,7 +51,6 @@ export const HumanSegmentEventType = {
 	[SegmentEventType.command_init_start]: "SliceMachine Init Start",
 	[SegmentEventType.command_init_identify]: "SliceMachine Init Identify",
 	[SegmentEventType.command_init_end]: "SliceMachine Init End",
-	[SegmentEventType.review]: "SliceMachine Review",
 	[SegmentEventType.sliceSimulator_open]: "SliceMachine Slice Simulator Open",
 	[SegmentEventType.sliceSimulator_isNotRunning]:
 		"SliceMachine Slice Simulator is not running",
@@ -135,15 +133,6 @@ type CommandInitEndSegmentEvent = SegmentEvent<
 	{ framework: string; success: boolean; error?: string }
 >;
 
-type ReviewSegmentEvent = SegmentEvent<
-	typeof SegmentEventType.review,
-	{
-		rating: number;
-		comment: string;
-		type: "onboarding";
-	}
->;
-
 type SliceSimulatorOpenSegmentEvent = SegmentEvent<
 	typeof SegmentEventType.sliceSimulator_open
 >;
@@ -431,7 +420,6 @@ export type SegmentEvents =
 	| CommandInitStartSegmentEvent
 	| CommandInitIdentifySegmentEvent
 	| CommandInitEndSegmentEvent
-	| ReviewSegmentEvent
 	| SliceSimulatorOpenSegmentEvent
 	| SliceSimulatorIsNotRunningSegmentEvent
 	| PageViewSegmentEvent