@prismicio/types-internal 4.0.0-pr.6.38cb7de → 4.0.0-pr.6.6ce647d

package/src/helpers/documentContent.ts

@@ -5,10 +5,15 @@ 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>(
@@ -37,7 +42,10 @@ export function collectWidgets<TWidgetContent extends WidgetContent>(
 	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
@@ -67,6 +75,29 @@ export function fromLegacy(legacy: DocumentLegacy): DocumentContent | undefined
 		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,6 +24,7 @@ import type { NestableModel } from "../model/nestable"
 import type {
 	CompositeSliceModel,
 	LegacySliceModel,
+	SharedSliceModel,
 	SharedSliceVariationContentModel,
 	SliceContentModel,
 } from "../model/slice"
@@ -89,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: SharedSliceVariationContentModel | 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,
@@ -118,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,
@@ -127,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,
@@ -207,7 +250,7 @@ export function traverseSharedSliceContent(
 }
 
 type TraverseCompositeSliceContentConfig = {
-	model?: CompositeSliceModel
+	model?: CompositeSliceModel | SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentFunction
 	transformSlice?: TraverseSliceContentFunction
 }
@@ -218,20 +261,22 @@ export function traverseCompositeSliceContent(
 	apiID: string,
 	content: CompositeSliceItemContent,
 	config: TraverseCompositeSliceContentConfig,
-): CompositeSliceItemContent | undefined {
+): 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)) {
@@ -239,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({
@@ -258,7 +305,7 @@ export function traverseCompositeSliceContent(
 }
 
 type TraverseLegacySliceContentConfig = {
-	model?: LegacySliceModel
+	model?: LegacySliceModel | SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentFunction
 	transformSlice?: TraverseSliceContentFunction
 }
@@ -269,15 +316,30 @@ export function traverseLegacySliceContent(
 	apiID: string,
 	content: LegacySliceItemContent,
 	config: TraverseLegacySliceContentConfig,
-): LegacySliceItemContent | undefined {
+): 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,
 	})
@@ -467,7 +529,7 @@ export type TraverseSliceContentFunction = <TContent extends SliceItemContent>(a
 	apiID: string
 	content: TContent
 	model?: SliceContentModel
-}) => TContent | undefined
+}) => TContent | SharedSliceItemContent | undefined
 
 export type TraverseWidgetContentFunction<
 	TContentTransformMode extends "preserve" | "widen" = "preserve",

package/src/helpers/traverseContentWithModel.ts

@@ -96,49 +96,70 @@ export function traverseSlicesContentWithModel(
 
 	const traversed: SlicesContent["value"] = []
 	for (const sliceItemContent of content.value) {
-		const model = config.model.config?.choices?.[sliceItemContent.name]
+		const sliceModel = config.model.config?.choices?.[sliceItemContent.name]
 
 		let traversedSliceItemContent: SliceItemContent | undefined
-		if (
-			model?.type === "SharedSlice" &&
-			sliceItemContent.widget.__TYPE__ === SharedSliceContentType
-		) {
-			const variationID = sliceItemContent.widget.variation
-			const variationModel = model.variations.find((variation) => variation.id === variationID)
-			if (variationModel) {
-				const sharedSliceVariationModel: SharedSliceVariationContentModel = {
-					type: "SharedSlice",
-					sliceName: model.id,
-					variationID,
-					fields: {
-						primary: variationModel.primary || {},
-						items: variationModel.items || {},
-					},
+		if (sliceModel?.type === "SharedSlice") {
+			if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
+				// Happy path, content and model are both shared slices
+				const variationID = sliceItemContent.widget.variation
+				const variationModel = sliceModel.variations.find(
+					(variation) => variation.id === variationID,
+				)
+				if (variationModel) {
+					const model: SharedSliceVariationContentModel = {
+						type: "SharedSlice",
+						sliceName: sliceModel.id,
+						variationID: variationModel.id,
+						fields: {
+							primary: variationModel.primary || {},
+							items: variationModel.items || {},
+						},
+					}
+
+					traversedSliceItemContent = traverseSharedSliceContentWithModel(
+						path.concat({ key: sliceItemContent.key, type: "SharedSlice" }),
+						sliceItemContent.key,
+						sliceItemContent.name,
+						sliceItemContent as SharedSliceItemContent,
+						{ model, transformWidget, transformSlice },
+					)
 				}
-
-				traversedSliceItemContent = traverseSharedSliceContentWithModel(
-					path.concat({ key: sliceItemContent.key, type: "SharedSlice" }),
+			} else if (sliceItemContent.widget.__TYPE__ === CompositeSliceContentType) {
+				// Migrated path, content is composite, model is shared slice
+				const variationModel = sliceModel.variations[0]
+				if (variationModel) {
+					const model: SharedSliceVariationContentModel = {
+						type: "SharedSlice",
+						sliceName: sliceModel.id,
+						variationID: variationModel.id,
+						fields: {
+							primary: variationModel.primary || {},
+							items: variationModel.items || {},
+						},
+					}
+
+					traversedSliceItemContent = traverseCompositeSliceContentWithModel(
+						path.concat({ key: sliceItemContent.key, type: "Slice" }),
+						sliceItemContent.key,
+						sliceItemContent.name,
+						sliceItemContent as CompositeSliceItemContent,
+						{ model, transformWidget, transformSlice },
+					)
+				}
+			}
+		} else if (sliceModel?.type === "Slice") {
+			if (sliceItemContent.widget.__TYPE__ === CompositeSliceContentType) {
+				traversedSliceItemContent = traverseCompositeSliceContentWithModel(
+					path.concat({ key: sliceItemContent.key, type: "Slice" }),
 					sliceItemContent.key,
 					sliceItemContent.name,
-					sliceItemContent as SharedSliceItemContent,
-					{ model: sharedSliceVariationModel, transformWidget, transformSlice },
+					sliceItemContent as CompositeSliceItemContent,
+					{ model: sliceModel, transformWidget, transformSlice },
 				)
 			}
 		} else if (
-			model?.type === "Slice" &&
-			sliceItemContent.widget.__TYPE__ === CompositeSliceContentType
-		) {
-			traversedSliceItemContent = traverseCompositeSliceContentWithModel(
-				path.concat({ key: sliceItemContent.key, type: "Slice" }),
-				sliceItemContent.key,
-				sliceItemContent.name,
-				sliceItemContent as CompositeSliceItemContent,
-				{ model, transformWidget, transformSlice },
-			)
-		} else if (
-			model &&
-			model?.type !== "SharedSlice" &&
-			model?.type !== "Slice" &&
+			sliceModel &&
 			sliceItemContent.widget.__TYPE__ !== SharedSliceContentType &&
 			sliceItemContent.widget.__TYPE__ !== CompositeSliceContentType
 		) {
@@ -147,7 +168,7 @@ export function traverseSlicesContentWithModel(
 				sliceItemContent.key,
 				sliceItemContent.name,
 				sliceItemContent as LegacySliceItemContent,
-				{ model, transformWidget, transformSlice },
+				{ model: sliceModel, transformWidget, transformSlice },
 			)
 		}
 
@@ -222,7 +243,7 @@ export function traverseSharedSliceContentWithModel(
 }
 
 type TraverseCompositeSliceContentWithModelConfig = {
-	model: CompositeSliceModel
+	model: CompositeSliceModel | SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentWithModelFunction
 	transformSlice?: TraverseSliceContentWithModelFunction
 }
@@ -233,7 +254,7 @@ export function traverseCompositeSliceContentWithModel(
 	apiID: string,
 	content: CompositeSliceItemContent | undefined,
 	config: TraverseCompositeSliceContentWithModelConfig,
-): CompositeSliceItemContent | undefined {
+): CompositeSliceItemContent | SharedSliceItemContent | undefined {
 	if (!content) {
 		return
 	}
@@ -241,8 +262,12 @@ export function traverseCompositeSliceContentWithModel(
 	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, model] of Object.entries(config.model?.["non-repeat"] ?? {})) {
+	for (const [key, model] of Object.entries(primaryModel ?? {})) {
 		const traversedContent = traverseWidgetContentWithModel(
 			path.concat({ key: "non-repeat", type: "primary" }, { key, type: "Widget" }),
 			key,
@@ -256,10 +281,12 @@ export function traverseCompositeSliceContentWithModel(
 		}
 	}
 
+	const itemsModel =
+		config.model?.type === "SharedSlice" ? config.model?.fields.items : config.model?.repeat
 	const traversedItems = traverseGroupItemsContentWithModel(
 		path.concat({ key: "repeat", type: "items" }),
 		content.widget.repeat,
-		{ model: config.model.repeat ?? {}, transformWidget },
+		{ model: itemsModel ?? {}, transformWidget },
 	)
 
 	return transformSlice({
@@ -286,7 +313,7 @@ export function traverseLegacySliceContentWithModel(
 	apiID: string,
 	content: LegacySliceItemContent | undefined,
 	config: TraverseLegacySliceContentWithModelConfig,
-): LegacySliceItemContent | undefined {
+): LegacySliceItemContent | SharedSliceItemContent | undefined {
 	if (!content) {
 		return
 	}
@@ -520,7 +547,7 @@ export type TraverseSliceContentWithModelFunction = <TContent extends SliceItemC
 	apiID: string
 	content?: TContent
 	model: SliceContentModel
-}) => TContent | undefined
+}) => TContent | SharedSliceItemContent | undefined
 
 export type TraverseWidgetContentWithModelFunction<
 	TContentTransformMode extends "preserve" | "widen" = "preserve",

package/src/index.ts

@@ -90,6 +90,7 @@ export { LegacyContentCtx, getFieldCtx, defaultCtx } from "./content/codec/legac
 export * as contentPath from "./helpers/contentPath"
 export * as customTypeModel from "./helpers/customTypeModel"
 export * as documentContent from "./helpers/documentContent"
+export * as sliceContent from "./helpers/sliceContent"
 export {
 	traverseDocumentContent,
 	traverseSlicesContent,

package/src/model/table.ts

@@ -1,4 +1,5 @@
 import { z } from "zod/mini"
+
 import { RichTextNodeType, type RichTextModel } from "./richText"
 
 const TableConfigSchema = z.object({
@@ -17,7 +18,7 @@ export const TableCellModelNodeTypes = [
 	RichTextNodeType.paragraph,
 	RichTextNodeType.strong,
 	RichTextNodeType.em,
-	RichTextNodeType.hyperlink
+	RichTextNodeType.hyperlink,
 ]
 
 export const TableCellModel: RichTextModel = {