@prismicio/types-internal 2.2.0-traverse.alpha-0 → 2.2.0-traverse.alpha-2

package/src/content/Document.ts

@@ -3,15 +3,26 @@ import { isLeft, isRight } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { type TraverseContentFn, ContentPath } from "../_internal/utils"
+import {
+	ContentPath,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../_internal/utils"
 import { WidgetKey } from "../common"
 import {
-	type StaticCustomType,
 	type StaticWidget,
+	collectSharedSlices,
 	flattenStaticWidgets,
+	StaticCustomType,
+	VariationFields,
 } from "../customtypes"
 import {
-	SliceContent,
+	CompositeSliceItemContent,
+	GroupItemContent,
+	isCompositeSliceItemContent,
+	isSimpleSliceItemContent,
+	SharedSliceItemContent,
+	SimpleSliceItemContent,
 	traverseGroupContent,
 	traverseSlices,
 	WidgetContent,
@@ -119,7 +130,10 @@ function extractMetadata(data: { [p: string]: unknown }): {
 	}
 }
 
-function parseLegacyDocument(legacyDoc: unknown): Document | undefined {
+function parseLegacyDocument(
+	legacyDoc: unknown,
+	customType: StaticCustomType,
+): Document | undefined {
 	const result = pipe(
 		// ensure it's the right document format first
 		t.record(WidgetKey, t.unknown).decode(legacyDoc),
@@ -131,7 +145,7 @@ function parseLegacyDocument(legacyDoc: unknown): Document | undefined {
 		}),
 	)
 
-	return isLeft(result) ? undefined : result.right
+	return isLeft(result) ? undefined : migrateDocument(result.right, customType)
 }
 
 function encodeToLegacyDocument(document: Document): DocumentLegacy {
@@ -153,9 +167,21 @@ export const DocumentLegacy = {
  * @param transform: A user function that provides a way to transform any kind of content wherever it is in a structured Prismic object content.
  * @returns a transformed document with the user's transformation applied with the transform function
  */
-export function traverseDocument(document: Document, model?: StaticCustomType) {
-	return (transform: TraverseContentFn): Document => {
-		const fieldDefs =
+export function traverseDocument({
+	document,
+	model,
+}: {
+	document: Document
+	model?: StaticCustomType
+}) {
+	return ({
+		transformWidget = ({ content }) => content,
+		transformSlice = ({ content }) => content,
+	}: {
+		transformWidget?: TraverseWidgetContentFn
+		transformSlice?: TraverseSliceContentFn
+	}): Document => {
+		const fieldModels =
 			model &&
 			flattenStaticWidgets(model).reduce<Record<string, StaticWidget>>(
 				(acc, [key, def]) => ({ ...acc, [key]: def }),
@@ -163,40 +189,49 @@ export function traverseDocument(document: Document, model?: StaticCustomType) {
 			)
 
 		return Object.entries(document).reduce((acc, [key, content]) => {
-			const fieldDef = fieldDefs && fieldDefs[key]
+			const fieldModel = fieldModels && fieldModels[key]
+
+			const path = ContentPath.make([
+				{ key: model?.id, type: "CustomType" },
+				{ key, type: "Widget" },
+			])
 
-			const path = [{ key, type: content.__TYPE__ }]
-			const transformedWidgetContent = (() => {
+			const transformedWidget = (() => {
 				switch (content.__TYPE__) {
 					case "SliceContentType":
 						return traverseSlices({
 							path,
+							key,
 							model:
-								fieldDef?.type === "Slices" || fieldDef?.type === "Choice"
-									? fieldDef
+								fieldModel?.type === "Slices" || fieldModel?.type === "Choice"
+									? fieldModel
 									: undefined,
 							content,
-						})(transform)
+						})(transformWidget, transformSlice)
 					case "GroupContentType":
 						return traverseGroupContent({
 							path,
-							model: fieldDef?.type === "Group" ? fieldDef : undefined,
+							key,
+							apiId: key,
+							model: fieldModel?.type === "Group" ? fieldModel : undefined,
 							content,
-						})(transform)
+						})(transformWidget)
 					default:
-						return content
+						return transformWidget({
+							path,
+							key,
+							apiId: key,
+							model:
+								fieldModel?.type !== "Group" &&
+								fieldModel?.type !== "Slices" &&
+								fieldModel?.type !== "Choice"
+									? fieldModel
+									: undefined,
+							content,
+						})
 				}
 			})()
 
-			const transformedWidget =
-				transformedWidgetContent &&
-				transform({
-					path,
-					key,
-					apiId: key,
-					model: fieldDef,
-					content: transformedWidgetContent,
-				})
 			return {
 				...acc,
 				...(transformedWidget ? { [key]: transformedWidget } : {}),
@@ -205,26 +240,126 @@ export function traverseDocument(document: Document, model?: StaticCustomType) {
 	}
 }
 
-/**
- * The goal is to be able to collect all widgets or slices of a given type at any level of nesting inside a prismic content
- *
- * @param document parsed prismic content
- * @param is typeguard to match specifically the type of widget we want to collect
- * @returns a record containing the path of the widget as key and the typed collected content as value
- */
-export function collectWidgets<W extends WidgetContent | SliceContent>(
+// /**
+//  * The goal is to be able to collect all widgets or slices of a given type at any level of nesting inside a prismic content
+//  *
+//  * @param document parsed prismic content
+//  * @param is typeguard to match specifically the type of widget we want to collect
+//  * @returns a record containing the path of the widget as key and the typed collected content as value
+//  */
+export function collectWidgets<W extends WidgetContent>(
 	document: Document,
-	is: (
-		content: WidgetContent | SliceContent,
-		path: ContentPath,
-	) => content is W,
+	is: (content: WidgetContent, path: ContentPath) => content is W,
 ): Record<string, W> {
 	const collected: Record<string, W> = {}
 
-	traverseDocument(document)(({ content, path }) => {
-		const key = ContentPath.serialize(path)
-		if (is(content, path)) collected[key] = content
-		return content
+	traverseDocument({ document })({
+		transformWidget: ({ content, path }) => {
+			const key = ContentPath.serialize(path)
+			if (is(content, path)) collected[key] = content
+			return content
+		},
 	})
 	return collected
 }
+
+function migrateCompositeSlice(
+	model: VariationFields,
+	content: CompositeSliceItemContent,
+): SharedSliceItemContent {
+	return {
+		key: content.key,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationId,
+			primary: Object.entries(content.widget.nonRepeat).reduce(
+				(acc, [fieldKey, fieldContent]) => {
+					return model.fields.primary?.[fieldKey]
+						? { ...acc, [fieldKey]: fieldContent }
+						: acc
+				},
+				{},
+			),
+			items: content.widget.repeat.map((groupItem) => {
+				return {
+					__TYPE__: "GroupItemContent",
+					value: groupItem.value.reduce<GroupItemContent["value"]>(
+						(acc, [fieldKey, fieldContent]) => {
+							return model.fields.items?.[fieldKey]
+								? acc.concat([[fieldKey, fieldContent]])
+								: acc
+						},
+						[],
+					),
+				}
+			}, []),
+		},
+	}
+}
+
+function migrateSimpleSlice(
+	model: VariationFields,
+	content: SimpleSliceItemContent,
+): SharedSliceItemContent {
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		return {
+			key: content.key,
+			name: model.sliceName,
+			maybeLabel: content.maybeLabel,
+			widget: {
+				__TYPE__: "SharedSliceContent",
+				variation: model.variationId,
+				primary: {},
+				items: content.widget.value.map((groupItem) => {
+					return {
+						__TYPE__: "GroupItemContent",
+						value: groupItem.value.reduce<GroupItemContent["value"]>(
+							(acc, [fieldKey, fieldContent]) => {
+								return model.fields.items?.[fieldKey]
+									? acc.concat([[fieldKey, fieldContent]])
+									: acc
+							},
+							[],
+						),
+					}
+				}, []),
+			},
+		}
+	}
+	return {
+		key: content.key,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationId,
+			primary: model.fields.primary?.[content.name]
+				? { [content.key]: content.widget }
+				: {},
+			items: [],
+		},
+	}
+}
+
+export function migrateDocument(document: Document, model: StaticCustomType) {
+	const needsMigration = Object.values(collectSharedSlices(model)).some(
+		(slice) => Boolean(slice.legacyPaths),
+	)
+
+	if (!needsMigration) return document
+
+	return traverseDocument({
+		document,
+		model,
+	})({
+		transformSlice: ({ content, model }) => {
+			if (isCompositeSliceItemContent(content) && model?.type === "SharedSlice")
+				return migrateCompositeSlice(model, content)
+			if (isSimpleSliceItemContent(content) && model?.type === "SharedSlice")
+				return migrateSimpleSlice(model, content)
+			return content
+		},
+	})
+}

package/src/content/fields/GroupContent.ts

@@ -3,8 +3,11 @@ import { isLeft } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import type { ContentPath, TraverseContentFn } from "../../_internal/utils"
-import type { Group } from "../../customtypes"
+import type {
+	ContentPath,
+	TraverseWidgetContentFn,
+} from "../../_internal/utils"
+import type { Group, NestableWidget } from "../../customtypes"
 import {
 	FieldOrSliceType,
 	getFieldCtx,
@@ -12,7 +15,7 @@ import {
 	WithTypes,
 } from "../LegacyContentCtx"
 import { hasContentType } from "../utils"
-import { NestableContent, NestableLegacy } from "./nestable"
+import { isNestableContent, NestableContent, NestableLegacy } from "./nestable"
 
 export const GroupItemContentType = "GroupItemContent" as const
 
@@ -122,31 +125,67 @@ export type GroupContent = t.TypeOf<typeof GroupContent>
 
 export function traverseGroupContent({
 	path,
+	key,
+	apiId,
 	model,
 	content,
 }: {
 	path: ContentPath
+	key: string
+	apiId: string
 	content: GroupContent
 	model?: Group | undefined
 }) {
-	return (transform: TraverseContentFn): GroupContent | undefined => {
-		const groupItems = content.value.map((groupItem, index) => {
+	return (transform: TraverseWidgetContentFn): GroupContent | undefined => {
+		const groupItems = traverseGroupItemsContent({
+			path,
+			model: model?.config?.fields,
+			content: content.value,
+		})(transform)
+
+		return transform({
+			path,
+			key,
+			apiId,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				value: groupItems,
+			},
+		})
+	}
+}
+
+export function traverseGroupItemsContent({
+	path,
+	model,
+	content,
+}: {
+	path: ContentPath
+	content: Array<GroupItemContent>
+	model?: Record<string, NestableWidget> | undefined
+}) {
+	return (transform: TraverseWidgetContentFn): Array<GroupItemContent> => {
+		return content.map((groupItem, index) => {
+			const groupItemPath = path.concat([
+				{ key: index.toString(), type: "GroupItem" },
+			])
+
 			const groupItemFields = groupItem.value.reduce<GroupItemContent["value"]>(
 				(acc, [fieldKey, fieldContent]) => {
-					const fieldDef = model?.config?.fields?.[fieldKey]
+					const fieldDef = model?.[fieldKey]
 
 					const transformedField = transform({
-						path: path.concat([
-							{ key: index.toString(), type: "GroupItem" },
-							{ key: fieldKey, type: fieldContent.__TYPE__ },
-						]),
+						path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
 						key: fieldKey,
 						apiId: fieldKey,
 						model: fieldDef,
 						content: fieldContent,
 					})
 					// Can happen if the transform function returns undefined to filter out a field
-					if (!transformedField) return acc
+					if (!transformedField || !isNestableContent(transformedField))
+						return acc
+
 					return acc.concat([[fieldKey, transformedField]])
 				},
 				[],
@@ -157,10 +196,5 @@ export function traverseGroupContent({
 				value: groupItemFields,
 			}
 		})
-
-		return {
-			__TYPE__: content.__TYPE__,
-			value: groupItems,
-		}
 	}
 }

package/src/content/fields/slices/Slice/CompositeSliceContent.ts

@@ -5,17 +5,29 @@ import * as t from "io-ts"
 
 import type {
 	ContentPath,
-	TraverseContentFn,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
-import type { CompositeSlice } from "../../../../customtypes"
+import type {
+	CompositeSliceFields,
+	VariationFields,
+} from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
-import type { GroupItemContent } from "../../GroupContent"
-import { NestableContent, NestableLegacy } from "../../nestable"
+import { traverseGroupItemsContent } from "../../GroupContent"
+import {
+	isNestableContent,
+	NestableContent,
+	NestableLegacy,
+} from "../../nestable"
+import type {
+	CompositeSliceItemContent,
+	SharedSliceItemContent,
+} from "../SliceItem"
 import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
 export const CompositeSliceContentType = "CompositeSliceContent"
@@ -126,25 +138,34 @@ export type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>
 
 export function traverseCompositeSliceContent({
 	path,
+	sliceKey,
 	sliceName,
 	model,
 	content,
 }: {
 	path: ContentPath
+	sliceKey: string
 	sliceName: string
-	content: CompositeSliceContent
-	model?: CompositeSlice | undefined
+	content: CompositeSliceItemContent
+	model?: VariationFields | CompositeSliceFields | undefined
 }) {
-	return (transform: TraverseContentFn): CompositeSliceContent | undefined => {
-		const primary = Object.entries(content.nonRepeat).reduce<
-			Record<string, NestableContent>
+	return (
+		transformWidget: TraverseWidgetContentFn,
+		transformSlice: TraverseSliceContentFn,
+	): SharedSliceItemContent | CompositeSliceItemContent | undefined => {
+		const primary = Object.entries(content.widget.nonRepeat).reduce<
+			CompositeSliceContent["nonRepeat"]
 		>((acc, [fieldKey, fieldContent]) => {
-			const fieldDef = model?.["non-repeat"]?.[fieldKey]
+			const fieldDef = (() => {
+				return model?.type === "SharedSlice"
+					? model?.fields?.primary?.[fieldKey]
+					: model?.fields?.repeat?.[fieldKey]
+			})()
 
-			const transformedField = transform({
+			const transformedField = transformWidget({
 				path: path.concat([
 					{ key: "non-repeat", type: "primary" },
-					{ key: fieldKey, type: fieldContent.__TYPE__ },
+					{ key: fieldKey, type: "Widget" },
 				]),
 				key: fieldKey,
 				apiId: sliceName,
@@ -152,45 +173,35 @@ export function traverseCompositeSliceContent({
 				content: fieldContent,
 			})
 			// Can happen if the transform function returns undefined to filter out a field
-			if (!transformedField) return acc
+			if (!transformedField || !isNestableContent(transformedField)) return acc
 			return {
 				...acc,
 				[fieldKey]: transformedField,
 			}
 		}, {})
 
-		const items = content.repeat.map((itemBlock) => {
-			const itemBlockFields = itemBlock.value.reduce<GroupItemContent["value"]>(
-				(acc, [fieldKey, fieldContent]) => {
-					const fieldDef = model?.repeat?.[fieldKey]
-
-					const transformedField = transform({
-						path: path.concat([
-							{ key: "repeat", type: "items" },
-							{ key: fieldKey, type: fieldContent.__TYPE__ },
-						]),
-						key: fieldKey,
-						apiId: sliceName,
-						model: fieldDef,
-						content: fieldContent,
-					})
-					// Can happen if the transform function returns undefined to filter out a field
-					if (!transformedField) return acc
-					return acc.concat([[fieldKey, transformedField]])
+		const items = traverseGroupItemsContent({
+			path: path.concat([{ key: "repeat", type: "items" }]),
+			model:
+				model?.type === "SharedSlice"
+					? model?.fields.items
+					: model?.fields.repeat,
+			content: content.widget.repeat,
+		})(transformWidget)
+
+		return transformSlice({
+			key: sliceKey,
+			apiId: sliceName,
+			path,
+			model,
+			content: {
+				...content,
+				widget: {
+					__TYPE__: "CompositeSliceContent",
+					repeat: items,
+					nonRepeat: primary,
 				},
-				[],
-			)
-
-			return {
-				__TYPE__: itemBlock.__TYPE__,
-				value: itemBlockFields,
-			}
+			},
 		})
-
-		return {
-			__TYPE__: content.__TYPE__,
-			repeat: items,
-			nonRepeat: primary,
-		}
 	}
 }

package/src/content/fields/slices/Slice/SharedSliceContent.ts

@@ -6,17 +6,23 @@ import { withFallback } from "io-ts-types"
 
 import type {
 	ContentPath,
-	TraverseContentFn,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
-import type { SharedSlice } from "../../../../customtypes"
+import type { VariationFields } from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
-import type { GroupItemContent } from "../../GroupContent"
-import { NestableContent, NestableLegacy } from "../../nestable"
+import { traverseGroupItemsContent } from "../../GroupContent"
+import {
+	isNestableContent,
+	NestableContent,
+	NestableLegacy,
+} from "../../nestable"
+import type { SharedSliceItemContent } from "../SliceItem"
 import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
 export const SharedSliceContentType = "SharedSliceContent"
@@ -137,29 +143,30 @@ export type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>
 
 export function traverseSharedSliceContent({
 	path,
+	sliceKey,
 	sliceName,
 	model,
 	content,
 }: {
 	path: ContentPath
+	sliceKey: string
 	sliceName: string
-	content: SharedSliceContent
-	model?: SharedSlice | undefined
+	content: SharedSliceItemContent
+	model?: VariationFields | undefined
 }) {
-	return (transform: TraverseContentFn): SharedSliceContent | undefined => {
-		const variationDef = model?.variations.find(
-			(v) => v.id === content.variation,
-		)
-
-		const primary = Object.entries(content.primary).reduce<
-			Record<string, NestableContent>
+	return (
+		transformWidget: TraverseWidgetContentFn,
+		transformSlice: TraverseSliceContentFn,
+	): SharedSliceItemContent | undefined => {
+		const primary = Object.entries(content.widget.primary).reduce<
+			SharedSliceContent["primary"]
 		>((acc, [fieldKey, fieldContent]) => {
-			const fieldDef = variationDef && variationDef.primary?.[fieldKey]
+			const fieldDef = model?.fields?.primary?.[fieldKey]
 
-			const transformedField = transform({
+			const transformedField = transformWidget({
 				path: path.concat([
 					{ key: "primary", type: "primary" },
-					{ key: fieldKey, type: fieldContent.__TYPE__ },
+					{ key: fieldKey, type: "Widget" },
 				]),
 				key: fieldKey,
 				apiId: sliceName,
@@ -167,46 +174,33 @@ export function traverseSharedSliceContent({
 				content: fieldContent,
 			})
 			// Can happen if the transform function returns undefined to filter out a field
-			if (!transformedField) return acc
+			if (!transformedField || !isNestableContent(transformedField)) return acc
 			return {
 				...acc,
 				[fieldKey]: transformedField,
 			}
 		}, {})
 
-		const items = content.items.map((itemBlock) => {
-			const itemBlockFields = itemBlock.value.reduce<GroupItemContent["value"]>(
-				(acc, [fieldKey, fieldContent]) => {
-					const fieldDef = variationDef && variationDef.items?.[fieldKey]
-
-					const transformedField = transform({
-						path: path.concat([
-							{ key: "items", type: "items" },
-							{ key: fieldKey, type: fieldContent.__TYPE__ },
-						]),
-						key: fieldKey,
-						apiId: sliceName,
-						model: fieldDef,
-						content: fieldContent,
-					})
-					// Can happen if the transform function returns undefined to filter out a field
-					if (!transformedField) return acc
-					return acc.concat([[fieldKey, transformedField]])
+		const items = traverseGroupItemsContent({
+			path: path.concat([{ key: "items", type: "items" }]),
+			model: model?.fields.items,
+			content: content.widget.items,
+		})(transformWidget)
+
+		return transformSlice({
+			key: sliceKey,
+			apiId: sliceName,
+			path,
+			model: model,
+			content: {
+				...content,
+				widget: {
+					__TYPE__: "SharedSliceContent",
+					variation: content.widget.variation,
+					primary,
+					items,
 				},
-				[],
-			)
-
-			return {
-				__TYPE__: itemBlock.__TYPE__,
-				value: itemBlockFields,
-			}
+			},
 		})
-
-		return {
-			__TYPE__: content.__TYPE__,
-			variation: content.variation,
-			primary,
-			items,
-		}
 	}
 }