@prismicio/types-internal 4.0.0-pr.6.e3136c3 → 4.0.0-pr.7.9dec8db

package/src/helpers/documentContent.ts

@@ -5,42 +5,47 @@ import { defaultCtx } from "../content/codec/legacyContentCtx"
 import type { DocumentContent } from "../content/document"
 import type { DocumentLegacy } from "../content/legacy/document"
 import { DocumentLegacySchema } from "../content/legacy/document"
+import { isNestableContent } from "../content/nestable"
+import type { CompositeSliceItemContent, LegacySliceItemContent } from "../content/slices"
 import type { WidgetContent } from "../content/widget"
+import type { StaticCustomTypeModel } from "../model/customType"
 import type { FieldOrSliceType } from "../model/widget"
 import { FieldOrSliceTypeSchema } from "../model/widget"
 import * as contentPath from "./contentPath"
+import * as customTypeModel from "./customTypeModel"
+import * as sliceContent from "./sliceContent"
 import { traverseDocumentContent } from "./traverseContent"
 
 export function collectWidgets<TWidgetContent extends WidgetContent>(
 	document: DocumentContent,
-	test: (args: {
-		path: contentPath.Path
-		key: string
-		apiID: string
-		content: WidgetContent
-	}) => args is {
-		path: contentPath.Path
-		key: string
-		apiID: string
-		content: TWidgetContent
-	},
+	test: (
+		content: WidgetContent,
+		args: {
+			path: contentPath.Path
+			key: string
+			apiID: string
+		},
+	) => content is TWidgetContent,
 ): Record<string, TWidgetContent> {
 	const collected: Record<string, TWidgetContent> = {}
 
 	traverseDocumentContent(document, {
-		transformWidget: (args) => {
-			if (test(args)) {
-				collected[contentPath.serialize(args.path)] = args.content
+		transformWidget: ({ content, ...args }) => {
+			if (test(content, args)) {
+				collected[contentPath.serialize(args.path)] = content
 			}
 
-			return args.content
+			return content
 		},
 	})
 
 	return collected
 }
 
-export function fromLegacy(legacy: DocumentLegacy): DocumentContent | undefined {
+export function fromLegacy(
+	legacy: DocumentLegacy,
+	model: StaticCustomTypeModel,
+): DocumentContent | undefined {
 	const parsed = DocumentLegacySchema.safeParse(legacy)
 	if (!parsed.success) {
 		return
@@ -65,11 +70,34 @@ export function fromLegacy(legacy: DocumentLegacy): DocumentContent | undefined
 		}
 	}
 
-	const result = DocumentLegacyCodec(defaultCtx("", types, keys)).toContent(parsed.data)
+	const result = DocumentLegacyCodec(defaultCtx("", types, keys)).toContent(widgets)
 	if (!result.success) {
 		return
 	}
 
+	const needsMigration = Object.values(customTypeModel.collectSharedSlices(model)).some((slice) =>
+		Boolean(slice.legacyPaths),
+	)
+
+	if (needsMigration) {
+		return traverseDocumentContent(result.data, {
+			model,
+			transformSlice: ({ content, model }) => {
+				if (model?.type === "SharedSlice") {
+					if (content.widget.__TYPE__ === "CompositeSliceContent") {
+						return sliceContent.compositeToShared(content as CompositeSliceItemContent, model)
+					} else if (
+						content.widget.__TYPE__ === "GroupContentType" ||
+						isNestableContent(content.widget)
+					) {
+						return sliceContent.legacyToShared(content as LegacySliceItemContent, model)
+					}
+				}
+				return content
+			},
+		})
+	}
+
 	return result.data
 }
 

package/src/helpers/sliceContent.ts

@@ -0,0 +1,86 @@
+import type { GroupItemContent } from "../content/group"
+import type { SharedSliceContent } from "../content/slice"
+import type {
+	CompositeSliceItemContent,
+	LegacySliceItemContent,
+	SharedSliceItemContent,
+} from "../content/slices"
+import type { SharedSliceVariationContentModel } from "../model/slice"
+
+export const legacyToShared = (
+	content: LegacySliceItemContent,
+	model: SharedSliceVariationContentModel,
+): SharedSliceItemContent => {
+	const sliceUUID = content.key.split("$")[1]
+
+	const primary: SharedSliceContent["primary"] = {}
+	const items: SharedSliceContent["items"] = []
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		// Group content
+		for (const item of content.widget.value) {
+			const value: GroupItemContent["value"] = []
+
+			for (const [key, nestable] of item.value) {
+				if (model.fields.items?.[key]) {
+					value.push([key, nestable])
+				}
+			}
+
+			items.push({ ...item, value })
+		}
+	} else if (model.fields.primary?.[content.name]) {
+		// Nestable content
+		primary[content.name] = content.widget
+	}
+
+	return {
+		key: `${model.sliceName}$${sliceUUID}`,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationID,
+			primary,
+			items,
+		},
+	}
+}
+
+export const compositeToShared = (
+	content: CompositeSliceItemContent,
+	model: SharedSliceVariationContentModel,
+): SharedSliceItemContent => {
+	const sliceUUID = content.key.split("$")[1]
+
+	const primary: SharedSliceContent["primary"] = {}
+	for (const [key, value] of Object.entries(content.widget.nonRepeat)) {
+		if (model.fields.primary?.[key]) {
+			primary[key] = value
+		}
+	}
+
+	const items: SharedSliceContent["items"] = []
+	for (const item of content.widget.repeat) {
+		const value: GroupItemContent["value"] = []
+
+		for (const [key, nestable] of item.value) {
+			if (model.fields.items?.[key]) {
+				value.push([key, nestable])
+			}
+		}
+
+		items.push({ ...item, value })
+	}
+
+	return {
+		key: `${model.sliceName}$${sliceUUID}`,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationID,
+			primary,
+			items,
+		},
+	}
+}

package/src/helpers/traverseContent.ts

@@ -24,7 +24,9 @@ import type { NestableModel } from "../model/nestable"
 import type {
 	CompositeSliceModel,
 	LegacySliceModel,
-	SharedSliceVariationModel,
+	SharedSliceModel,
+	SharedSliceVariationContentModel,
+	SliceContentModel,
 } from "../model/slice"
 import type { StaticSlicesModel } from "../model/slices"
 import { TableCellModel } from "../model/table"
@@ -88,27 +90,67 @@ export function traverseSlicesContent(
 	for (const sliceItemContent of content.value) {
 		const sliceModel = config.model?.config?.choices?.[sliceItemContent.name]
 
-		let traversedSliceItemContent: SliceItemContent | undefined
-		if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
-			let model: SharedSliceVariationModel | undefined
-			if (sliceModel?.type === "SharedSlice") {
-				const variationID = sliceItemContent.widget.variation
-				const variationModel = sliceModel.variations.find(
-					(variation) => variation.id === variationID,
-				)
-				if (variationModel) {
-					model = {
+		let sliceContentModel: SliceContentModel | undefined
+
+		// Happy path, content and model are both shared slices
+		if (
+			sliceItemContent.widget.__TYPE__ === SharedSliceContentType &&
+			sliceModel?.type === "SharedSlice"
+		) {
+			const variationID = sliceItemContent.widget.variation
+			const variationModel = sliceModel.variations.find((variation) => variation.id === variationID)
+			if (variationModel) {
+				sliceContentModel = {
+					type: "SharedSlice",
+					sliceName: sliceModel.id,
+					variationID: variationModel.id,
+					fields: {
+						primary: variationModel.primary || {},
+						items: variationModel.items || {},
+					},
+				}
+			}
+		}
+
+		// Migrated path, content is composite or legacy, model is shared slice
+		if (!sliceContentModel) {
+			const legacyPath = contentPath.append(contentPath.serialize(path), sliceItemContent.name)
+
+			// Find the migrated slice model who's legacy path matches the content path
+			const migratedSliceModel = Object.values(config.model?.config?.choices || {}).find(
+				(model): model is SharedSliceModel => {
+					return model.type === "SharedSlice" && Boolean(model.legacyPaths?.[legacyPath])
+				},
+			)
+
+			if (migratedSliceModel) {
+				// Find the variation that matches the legacy path
+				const variation = migratedSliceModel.variations.find((variation) => {
+					return variation.id === migratedSliceModel.legacyPaths?.[legacyPath]
+				})
+
+				if (variation) {
+					sliceContentModel = {
 						type: "SharedSlice",
-						sliceName: sliceModel.id,
-						variationID,
+						sliceName: migratedSliceModel.id,
+						variationID: variation.id,
 						fields: {
-							primary: variationModel.primary || {},
-							items: variationModel.items || {},
+							primary: variation.primary || {},
+							items: variation.items || {},
 						},
 					}
 				}
 			}
+		}
 
+		// Non-migrated path, content and model are composite or legacy
+		if (!sliceContentModel && sliceModel && sliceModel.type !== "SharedSlice") {
+			sliceContentModel = sliceModel
+		}
+
+		let traversedSliceItemContent: SliceItemContent | undefined
+		if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
+			const model = sliceContentModel?.type === "SharedSlice" ? sliceContentModel : undefined
 			traversedSliceItemContent = traverseSharedSliceContent(
 				path.concat({ key: sliceItemContent.key, type: "SharedSlice" }),
 				sliceItemContent.key,
@@ -117,7 +159,10 @@ export function traverseSlicesContent(
 				{ model, transformWidget, transformSlice },
 			)
 		} else if (sliceItemContent.widget.__TYPE__ === CompositeSliceContentType) {
-			const model = sliceModel?.type === "Slice" ? sliceModel : undefined
+			const model =
+				sliceContentModel?.type === "Slice" || sliceContentModel?.type === "SharedSlice"
+					? sliceContentModel
+					: undefined
 			traversedSliceItemContent = traverseCompositeSliceContent(
 				path.concat({ key: sliceItemContent.key, type: "Slice" }),
 				sliceItemContent.key,
@@ -126,8 +171,7 @@ export function traverseSlicesContent(
 				{ model, transformWidget, transformSlice },
 			)
 		} else {
-			const model =
-				sliceModel?.type !== "SharedSlice" && sliceModel?.type !== "Slice" ? sliceModel : undefined
+			const model = sliceContentModel?.type !== "Slice" ? sliceContentModel : undefined
 			traversedSliceItemContent = traverseLegacySliceContent(
 				path.concat({ key: sliceItemContent.key, type: "LegacySlice" }),
 				sliceItemContent.key,
@@ -152,9 +196,9 @@ export function traverseSlicesContent(
 }
 
 type TraverseSharedSliceContentConfig = {
-	model?: SharedSliceVariationModel
-	transformWidget: TraverseWidgetContentFunction
-	transformSlice: TraverseSliceContentFunction
+	model?: SharedSliceVariationContentModel
+	transformWidget?: TraverseWidgetContentFunction
+	transformSlice?: TraverseSliceContentFunction
 }
 
 export function traverseSharedSliceContent(
@@ -164,7 +208,8 @@ export function traverseSharedSliceContent(
 	content: SharedSliceItemContent,
 	config: TraverseSharedSliceContentConfig,
 ): SharedSliceItemContent | undefined {
-	const { transformWidget, transformSlice } = config
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
 
 	const traversedPrimary: SharedSliceContent["primary"] = {}
 	for (const [key, fieldContent] of Object.entries(content.widget.primary)) {
@@ -205,9 +250,9 @@ export function traverseSharedSliceContent(
 }
 
 type TraverseCompositeSliceContentConfig = {
-	model?: CompositeSliceModel
-	transformWidget: TraverseWidgetContentFunction
-	transformSlice: TraverseSliceContentFunction
+	model?: CompositeSliceModel | SharedSliceVariationContentModel
+	transformWidget?: TraverseWidgetContentFunction
+	transformSlice?: TraverseSliceContentFunction
 }
 
 export function traverseCompositeSliceContent(
@@ -216,19 +261,22 @@ export function traverseCompositeSliceContent(
 	apiID: string,
 	content: CompositeSliceItemContent,
 	config: TraverseCompositeSliceContentConfig,
-): CompositeSliceItemContent | undefined {
-	const { transformWidget, transformSlice } = config
+): CompositeSliceItemContent | SharedSliceItemContent | undefined {
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
 
+	const primaryModel =
+		config.model?.type === "SharedSlice"
+			? config.model?.fields.primary
+			: config.model?.["non-repeat"]
 	const traversedPrimary: CompositeSliceContent["nonRepeat"] = {}
 	for (const [key, fieldContent] of Object.entries(content.widget.nonRepeat)) {
-		const model = config.model?.["non-repeat"]?.[key]
-
 		const traversedContent = traverseWidgetContent(
 			path.concat({ key: "non-repeat", type: "primary" }, { key, type: "Widget" }),
 			key,
 			apiID,
 			fieldContent,
-			{ model, transformWidget },
+			{ model: primaryModel?.[key], transformWidget },
 		)
 
 		if (traversedContent && isNestableContent(traversedContent)) {
@@ -236,10 +284,12 @@ export function traverseCompositeSliceContent(
 		}
 	}
 
+	const itemsModel =
+		config.model?.type === "SharedSlice" ? config.model?.fields.items : config.model?.repeat
 	const traversedItems = traverseGroupItemsContent(
 		path.concat({ key: "repeat", type: "items" }),
 		content.widget.repeat,
-		{ model: config.model?.repeat, transformWidget },
+		{ model: itemsModel, transformWidget },
 	)
 
 	return transformSlice({
@@ -255,9 +305,9 @@ export function traverseCompositeSliceContent(
 }
 
 type TraverseLegacySliceContentConfig = {
-	model?: LegacySliceModel
-	transformWidget: TraverseWidgetContentFunction
-	transformSlice: TraverseSliceContentFunction
+	model?: LegacySliceModel | SharedSliceVariationContentModel
+	transformWidget?: TraverseWidgetContentFunction
+	transformSlice?: TraverseSliceContentFunction
 }
 
 export function traverseLegacySliceContent(
@@ -266,11 +316,30 @@ export function traverseLegacySliceContent(
 	apiID: string,
 	content: LegacySliceItemContent,
 	config: TraverseLegacySliceContentConfig,
-): LegacySliceItemContent | undefined {
-	const { model, transformWidget, transformSlice } = config
+): LegacySliceItemContent | SharedSliceItemContent | undefined {
+	const {
+		model,
+		transformWidget = (args) => args.content,
+		transformSlice = (args) => args.content,
+	} = config
+
+	let legacySliceModel: LegacySliceModel | undefined
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		if (model?.type === "Group") {
+			legacySliceModel = model
+		} else if (model?.type === "SharedSlice") {
+			legacySliceModel = { type: "Group", config: { fields: model.fields.items } }
+		}
+	} else {
+		if (model?.type === "SharedSlice") {
+			legacySliceModel = model.fields.primary?.[content.name]
+		} else if (model?.type !== "Group") {
+			legacySliceModel = model
+		}
+	}
 
 	const traversedContent = traverseWidgetContent(path, key, apiID, content.widget, {
-		model,
+		model: legacySliceModel,
 		transformWidget,
 		transformSlice,
 	})
@@ -459,8 +528,8 @@ export type TraverseSliceContentFunction = <TContent extends SliceItemContent>(a
 	key: string
 	apiID: string
 	content: TContent
-	model?: SliceModel
-}) => TContent | undefined
+	model?: SliceContentModel
+}) => TContent | SharedSliceItemContent | undefined
 
 export type TraverseWidgetContentFunction<
 	TContentTransformMode extends "preserve" | "widen" = "preserve",
@@ -473,8 +542,6 @@ export type TraverseWidgetContentFunction<
 }) => (TContentTransformMode extends "preserve" ? TContent : WidgetContent) | undefined
 
 // Internals
-type SliceModel = SharedSliceVariationModel | CompositeSliceModel | LegacySliceModel
-
 type TraverseWidgetContentConfig = {
 	model?: StaticWidgetModel
 	transformWidget?: TraverseWidgetContentFunction