@prismicio/types-internal 2.2.0-traverse.alpha-1 → 2.2.0-traverse.alpha-3

package/src/content/fields/GroupContent.ts

@@ -3,7 +3,10 @@ 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 {
+	ContentPath,
+	TraverseWidgetContentFn,
+} from "../../_internal/utils"
 import type { Group, NestableWidget } from "../../customtypes"
 import {
 	FieldOrSliceType,
@@ -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,24 +125,34 @@ 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 => {
+	return (transform: TraverseWidgetContentFn): GroupContent | undefined => {
 		const groupItems = traverseGroupItemsContent({
 			path,
 			model: model?.config?.fields,
 			content: content.value,
 		})(transform)
 
-		return {
-			__TYPE__: content.__TYPE__,
-			value: groupItems,
-		}
+		return transform({
+			path,
+			key,
+			apiId,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				value: groupItems,
+			},
+		})
 	}
 }
 
@@ -152,7 +165,7 @@ export function traverseGroupItemsContent({
 	content: Array<GroupItemContent>
 	model?: Record<string, NestableWidget> | undefined
 }) {
-	return (transform: TraverseContentFn): Array<GroupItemContent> => {
+	return (transform: TraverseWidgetContentFn): Array<GroupItemContent> => {
 		return content.map((groupItem, index) => {
 			const groupItemPath = path.concat([
 				{ key: index.toString(), type: "GroupItem" },
@@ -163,16 +176,16 @@ export function traverseGroupItemsContent({
 					const fieldDef = model?.[fieldKey]
 
 					const transformedField = transform({
-						path: groupItemPath.concat([
-							{ 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]])
 				},
 				[],

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 { traverseGroupItemsContent } from "../../GroupContent"
-import { NestableContent, NestableLegacy } from "../../nestable"
+import { GroupItemContent, 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 => {
-		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,7 +173,7 @@ 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,
@@ -161,14 +182,62 @@ export function traverseCompositeSliceContent({
 
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "repeat", type: "items" }]),
-			model: model?.repeat,
-			content: content.repeat,
-		})(transform)
-
-		return {
-			__TYPE__: content.__TYPE__,
-			repeat: items,
-			nonRepeat: primary,
-		}
+			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,
+				},
+			},
+		})
+	}
+}
+
+export 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
+						},
+						[],
+					),
+				}
+			}, []),
+		},
 	}
 }

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

@@ -6,9 +6,10 @@ 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,
@@ -16,7 +17,12 @@ import {
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
 import { traverseGroupItemsContent } from "../../GroupContent"
-import { NestableContent, NestableLegacy } from "../../nestable"
+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 => {
-		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,7 +174,7 @@ 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,
@@ -176,15 +183,24 @@ export function traverseSharedSliceContent({
 
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "items", type: "items" }]),
-			model: variationDef?.items,
-			content: content.items,
-		})(transform)
-
-		return {
-			__TYPE__: content.__TYPE__,
-			variation: content.variation,
-			primary,
-			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,
+				},
+			},
+		})
 	}
 }

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

@@ -1,12 +1,32 @@
 import * as t from "io-ts"
 
+import type {
+	ContentPath,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../../../../_internal/utils"
+import type {
+	Group,
+	NestableWidget,
+	VariationFields,
+} from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import { GroupContent, GroupLegacy, isGroupContent } from "../../GroupContent"
+import {
+	GroupContent,
+	GroupItemContent,
+	GroupLegacy,
+	isGroupContent,
+	traverseGroupContent,
+} from "../../GroupContent"
 import {
 	isNestableContent,
 	NestableContent,
 	NestableLegacy,
 } from "../../nestable"
+import type {
+	SharedSliceItemContent,
+	SimpleSliceItemContent,
+} from "../SliceItem"
 
 export const SimpleSliceContent = t.union([NestableContent, GroupContent])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
@@ -31,3 +51,126 @@ export const SimpleSliceLegacy = (ctx: LegacyContentCtx) => {
 		},
 	}
 }
+
+export function traverseSimpleSliceContent({
+	path,
+	sliceKey,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceKey: string
+	sliceName: string
+	content: SimpleSliceItemContent
+	model?: VariationFields | Group | NestableWidget | undefined
+}) {
+	return (
+		transformWidget: TraverseWidgetContentFn,
+		transformSlice: TraverseSliceContentFn,
+	): SharedSliceItemContent | SimpleSliceItemContent | undefined => {
+		if (isGroupContent(content.widget)) {
+			const convertedGroupWidget: GroupContent | undefined =
+				traverseGroupContent({
+					path,
+					key: content.key,
+					apiId: content.name,
+					model: (() => {
+						if (model?.type === "Group") return model
+						if (model?.type === "SharedSlice")
+							return {
+								type: "Group",
+								config: { fields: model.fields.items || {} },
+							}
+						return
+					})(),
+					content: content.widget,
+				})(transformWidget)
+
+			return (
+				convertedGroupWidget &&
+				transformSlice({
+					key: content.key,
+					apiId: content.name,
+					path,
+					model,
+					content: {
+						...content,
+						widget: convertedGroupWidget,
+					},
+				})
+			)
+		}
+
+		const convertedNestable: NestableContent | undefined = transformWidget({
+			key: content.key,
+			apiId: content.name,
+			path,
+			model: (() => {
+				if (model?.type === "SharedSlice")
+					return model.fields.primary?.[content.name]
+				if (model?.type !== "Group") return model
+				return
+			})(),
+			content: content.widget,
+		})
+
+		return (
+			convertedNestable &&
+			transformSlice({
+				key: sliceKey,
+				apiId: sliceName,
+				path,
+				model,
+				content: {
+					...content,
+					widget: convertedNestable,
+				},
+			})
+		)
+	}
+}
+
+export 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: [],
+		},
+	}
+}

package/src/content/fields/slices/SliceItem.ts

@@ -9,10 +9,21 @@ import {
 	LegacyContentCtx,
 	WithTypes,
 } from "../../LegacyContentCtx"
+import { isGroupContent } from "../GroupContent"
+import { isNestableContent } from "../nestable"
 import { SliceContent, SliceLegacy } from "./Slice"
-import { isCompositeSliceContent } from "./Slice/CompositeSliceContent"
-import { isSharedSliceContent } from "./Slice/SharedSliceContent"
-import { isSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import {
+	CompositeSliceContent,
+	isCompositeSliceContent,
+} from "./Slice/CompositeSliceContent"
+import {
+	isSharedSliceContent,
+	SharedSliceContent,
+} from "./Slice/SharedSliceContent"
+import {
+	isSimpleSliceContent,
+	SimpleSliceContent,
+} from "./Slice/SimpleSliceContent"
 
 export const SliceItemContent = t.type({
 	key: t.string,
@@ -21,6 +32,31 @@ export const SliceItemContent = t.type({
 	widget: SliceContent,
 })
 export type SliceItemContent = t.TypeOf<typeof SliceItemContent>
+export type SharedSliceItemContent = Omit<SliceItemContent, "widget"> & {
+	widget: SharedSliceContent
+}
+export function isSharedSliceItemContent(
+	item: SliceItemContent,
+): item is SharedSliceItemContent {
+	return isSharedSliceContent(item.widget)
+}
+
+export type CompositeSliceItemContent = Omit<SliceItemContent, "widget"> & {
+	widget: CompositeSliceContent
+}
+export function isCompositeSliceItemContent(
+	item: SliceItemContent,
+): item is CompositeSliceItemContent {
+	return isCompositeSliceContent(item.widget)
+}
+export type SimpleSliceItemContent = Omit<SliceItemContent, "widget"> & {
+	widget: SimpleSliceContent
+}
+export function isSimpleSliceItemContent(
+	item: SliceItemContent,
+): item is SimpleSliceItemContent {
+	return isGroupContent(item.widget) || isNestableContent(item.widget)
+}
 
 const itemLegacyReader = t.exact(
 	t.intersection([