@prismicio/types-internal 3.17.0-alpha.3 → 3.17.0

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

@@ -11,6 +11,7 @@ import {
 	isStaticSharedSlice,
 	NestableWidget,
 	SharedSlice,
+	Variation,
 	VariationFields,
 } from "../../../customtypes"
 import type {
@@ -21,16 +22,40 @@ import type {
 import {
 	ContentPath,
 	TraverseSliceContentFn,
+	TraverseSliceContentWithModelFn,
 	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn,
 } from "../../utils"
 import { hasContentType } from "../../utils"
-import { traverseCompositeSliceContent } from "./Slice/CompositeSliceContent"
-import { traverseSharedSliceContent } from "./Slice/SharedSliceContent"
-import { traverseSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import {
+	isGroupContent,
+	traverseGroupContentWithModel,
+	traverseGroupItemsContentWithModel,
+} from "../GroupContent"
+import {
+	isNestableContent,
+	isRepeatableContent,
+	isTableContent,
+	traverseRepeatableContentWithModel,
+	traverseTableContentWithModel,
+} from "../nestable"
+import {
+	CompositeSliceContent,
+	traverseCompositeSliceContent,
+} from "./Slice/CompositeSliceContent"
+import {
+	SharedSliceContent,
+	traverseSharedSliceContent,
+} from "./Slice/SharedSliceContent"
+import {
+	SimpleSliceContent,
+	traverseSimpleSliceContent,
+} from "./Slice/SimpleSliceContent"
 import {
 	isCompositeSliceItemContent,
 	isSharedSliceItemContent,
 	isSimpleSliceItemContent,
+	SharedSliceItemContent,
 	SliceItemContent,
 	sliceItemContentWithDefaultValues,
 	SlicesItemLegacy,
@@ -43,7 +68,11 @@ export const isSlicesContent = (u: unknown): u is SlicesContent =>
 
 type SlicesLegacy = Array<unknown>
 
-type SliceModel = VariationFields | NestableWidget | CompositeSlice | Group
+export type SliceModel =
+	| VariationFields
+	| NestableWidget
+	| CompositeSlice
+	| Group
 
 export const SlicesLegacy = (ctx: LegacyContentCtx) => {
 	const codec = t.array(SlicesItemLegacy(ctx))
@@ -288,3 +317,361 @@ export function traverseSlices({
 		})
 	}
 }
+
+function buildVariationFields(
+	sharedSlice: SharedSlice,
+	variation: Variation,
+): VariationFields {
+	return {
+		type: "SharedSlice",
+		sliceName: sharedSlice.id,
+		variationId: variation.id,
+		fields: {
+			primary: variation.primary ?? {},
+			items: variation.items ?? {},
+		},
+	}
+}
+
+export function traverseSharedSliceContentWithModel({
+	path,
+	sliceKey,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceKey: string
+	sliceName: string
+	model: VariationFields
+	content: SharedSliceItemContent | undefined
+}): (
+	transformWidget: TraverseWidgetContentWithModelFn,
+	transformSlice: TraverseSliceContentWithModelFn,
+) => SharedSliceItemContent | undefined {
+	return (transformWidget, transformSlice) => {
+		if (!content) {
+			return undefined
+		}
+
+		const primary = Object.entries(model.fields.primary ?? {}).reduce<
+			SharedSliceContent["primary"]
+		>((acc, [fieldKey, fieldModel]) => {
+			const fieldContent = content.widget.primary[fieldKey]
+
+			const fieldPath = path.concat([
+				{ key: "primary", type: "primary" },
+				{ key: fieldKey, type: "Widget" },
+			])
+
+			let transformedField
+			if (fieldModel.type === "Group") {
+				const groupContent = isGroupContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = traverseGroupContentWithModel({
+					path: fieldPath,
+					key: fieldKey,
+					model: fieldModel,
+					content: groupContent,
+				})(transformWidget)
+			} else if (
+				fieldModel.type === "Link" &&
+				fieldModel.config?.repeat === true
+			) {
+				const repeatableContent = isRepeatableContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = traverseRepeatableContentWithModel({
+					path: fieldPath,
+					key: fieldKey,
+					model: fieldModel,
+					content: repeatableContent,
+				})(transformWidget)
+			} else if (fieldModel.type === "Table") {
+				const tableContent = isTableContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = traverseTableContentWithModel({
+					path: fieldPath,
+					key: fieldKey,
+					model: fieldModel,
+					content: tableContent,
+				})(transformWidget)
+			} else {
+				const nestableContent = isNestableContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = transformWidget({
+					path: fieldPath,
+					key: fieldKey,
+					apiId: fieldKey,
+					model: fieldModel,
+					content: nestableContent,
+				})
+			}
+
+			if (!transformedField) return acc
+
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
+
+		const items = traverseGroupItemsContentWithModel({
+			path: path.concat([{ key: "items", type: "items" }]),
+			model: model.fields.items ?? {},
+			content: content.widget.items,
+		})(transformWidget)
+
+		return transformSlice({
+			key: sliceKey,
+			apiId: sliceName,
+			path,
+			model,
+			content: {
+				...content,
+				widget: {
+					__TYPE__: "SharedSliceContent",
+					variation: content.widget.variation,
+					primary,
+					items,
+				},
+			},
+		})
+	}
+}
+
+function traverseCompositeSliceContentWithModel({
+	path,
+	sliceKey,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceKey: string
+	sliceName: string
+	model: CompositeSlice | VariationFields
+	content: SliceItemContent | undefined
+}): (
+	transformWidget: TraverseWidgetContentWithModelFn,
+	transformSlice: TraverseSliceContentWithModelFn,
+) => SliceItemContent | undefined {
+	return (transformWidget, transformSlice) => {
+		if (!content || !isCompositeSliceItemContent(content)) {
+			return undefined
+		}
+
+		const nonRepeatModel =
+			model.type === "SharedSlice"
+				? model.fields.primary ?? {}
+				: model["non-repeat"] ?? {}
+		const repeatModel =
+			model.type === "SharedSlice"
+				? model.fields.items ?? {}
+				: model.repeat ?? {}
+
+		const nonRepeat = Object.entries(nonRepeatModel).reduce<
+			CompositeSliceContent["nonRepeat"]
+		>((acc, [fieldKey, fieldModel]) => {
+			const fieldContent = content.widget.nonRepeat[fieldKey]
+			const fieldPath = path.concat([
+				{ key: "non-repeat", type: "primary" },
+				{ key: fieldKey, type: "Widget" },
+			])
+
+			const nestableContent = isNestableContent(fieldContent)
+				? fieldContent
+				: undefined
+
+			const transformedField = transformWidget({
+				path: fieldPath,
+				key: fieldKey,
+				apiId: sliceName,
+				model: fieldModel,
+				content: nestableContent,
+			})
+
+			if (!transformedField || !isNestableContent(transformedField)) return acc
+
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
+
+		const repeat = traverseGroupItemsContentWithModel({
+			path: path.concat([{ key: "repeat", type: "items" }]),
+			model: repeatModel,
+			content: content.widget.repeat,
+		})(transformWidget)
+
+		return transformSlice({
+			key: sliceKey,
+			apiId: sliceName,
+			path,
+			model: model.type === "SharedSlice" ? model : model,
+			content: {
+				...content,
+				widget: {
+					__TYPE__: content.widget.__TYPE__,
+					nonRepeat,
+					repeat,
+				},
+			},
+		})
+	}
+}
+
+export function traverseSlicesWithModel({
+	path,
+	key,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	model: StaticSlices
+	content: SlicesContent | undefined
+}): (args: {
+	transformWidget: TraverseWidgetContentWithModelFn
+	transformSlice: TraverseSliceContentWithModelFn
+}) => SlicesContent | undefined {
+	return ({ transformWidget, transformSlice }) => {
+		const choices = model.config?.choices ?? {}
+
+		const value = (content?.value ?? []).reduce<SlicesContent["value"]>(
+			(acc, sliceContent) => {
+				const sliceName = sliceContent.name
+				const sliceModel = choices[sliceName]
+
+				if (!sliceModel) {
+					return acc
+				}
+
+				const slicePath = path.concat({
+					key: sliceContent.key,
+					type: isStaticSharedSlice(sliceModel)
+						? "SharedSlice"
+						: isCompositeSlice(sliceModel)
+						? "Slice"
+						: "LegacySlice",
+				})
+
+				let convertedSlice: SliceItemContent | undefined
+
+				if (isStaticSharedSlice(sliceModel)) {
+					if (isSharedSliceItemContent(sliceContent)) {
+						const variation = sliceModel.variations.find(
+							(v) => v.id === sliceContent.widget.variation,
+						)
+						if (variation) {
+							const variationFields = buildVariationFields(
+								sliceModel,
+								variation,
+							)
+							convertedSlice = traverseSharedSliceContentWithModel({
+								path: slicePath,
+								sliceKey: sliceContent.key,
+								sliceName,
+								model: variationFields,
+								content: sliceContent,
+							})(transformWidget, transformSlice)
+						}
+					} else if (isCompositeSliceItemContent(sliceContent)) {
+						const defaultVariation = sliceModel.variations[0]
+						if (defaultVariation) {
+							const variationFields = buildVariationFields(
+								sliceModel,
+								defaultVariation,
+							)
+							convertedSlice = traverseCompositeSliceContentWithModel({
+								path: slicePath,
+								sliceKey: sliceContent.key,
+								sliceName,
+								model: variationFields,
+								content: sliceContent,
+							})(transformWidget, transformSlice)
+						}
+					}
+				} else if (isCompositeSlice(sliceModel)) {
+					if (isCompositeSliceItemContent(sliceContent)) {
+						convertedSlice = traverseCompositeSliceContentWithModel({
+							path: slicePath,
+							sliceKey: sliceContent.key,
+							sliceName,
+							model: sliceModel,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+					}
+				} else if (isLegacySlice(sliceModel)) {
+					if (isSimpleSliceItemContent(sliceContent)) {
+						let convertedWidget: SimpleSliceContent | undefined
+
+						if (isGroupContent(sliceContent.widget)) {
+							const groupModel =
+								sliceModel?.type === "Group" ? sliceModel : undefined
+
+							if (groupModel) {
+								convertedWidget = traverseGroupContentWithModel({
+									path: slicePath,
+									key: sliceContent.key,
+									model: groupModel,
+									content: sliceContent.widget,
+								})(transformWidget)
+							}
+						} else if (isNestableContent(sliceContent.widget)) {
+							const nestableModel =
+								sliceModel?.type !== "Group" ? sliceModel : undefined
+
+							if (nestableModel) {
+								convertedWidget = transformWidget({
+									key: sliceContent.key,
+									apiId: sliceName,
+									path: slicePath,
+									model: nestableModel,
+									content: sliceContent.widget,
+								})
+							}
+						}
+
+						convertedSlice =
+							convertedWidget &&
+							transformSlice({
+								key: sliceContent.key,
+								apiId: sliceName,
+								path: slicePath,
+								model: sliceModel,
+								content: {
+									...sliceContent,
+									widget: convertedWidget,
+								},
+							})
+					}
+				}
+
+				if (convertedSlice) {
+					acc.push(convertedSlice)
+				}
+
+				return acc
+			},
+			[],
+		)
+
+		return transformWidget({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						value,
+				  }
+				: undefined,
+		})
+	}
+}

package/src/content/helpers.ts

@@ -0,0 +1,25 @@
+import * as t from "io-ts"
+import { v4 as uuid, validate as validateUuid } from "uuid"
+
+type WithContentType = { __TYPE__: string }
+export function hasContentType(obj: unknown): obj is WithContentType {
+	return typeof obj === "object" && obj !== null && "__TYPE__" in obj
+}
+
+const isUuid = (input: unknown): input is string =>
+	typeof input === "string" && validateUuid(input)
+
+const uuidWithFallback = new t.Type<string, string, unknown>(
+	"UUID",
+	isUuid,
+	(u, c) => {
+		if (typeof u === "undefined") return t.success(uuid())
+		if (isUuid(u)) return t.success(u)
+		return t.failure(u, c)
+	},
+	t.identity,
+)
+
+export function withKey<C extends t.Mixed>(codec: C) {
+	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
+}

package/src/content/utils.ts

@@ -1,6 +1,4 @@
 import { isRight } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-import { v4 as uuid, validate as validateUuid } from "uuid"
 
 import type {
 	CompositeSlice,
@@ -17,8 +15,10 @@ import {
 	SliceItemContent,
 	WidgetContent,
 } from "./fields"
+export { hasContentType, withKey } from "./helpers"
+import { hasContentType } from "./helpers"
 
-type WithFieldType = WithContentType & { type: FieldType }
+type WithFieldType = { __TYPE__: string; type: FieldType }
 export function hasFieldContentType(obj: unknown): obj is WithFieldType {
 	return (
 		hasContentType(obj) &&
@@ -29,29 +29,6 @@ export function hasFieldContentType(obj: unknown): obj is WithFieldType {
 	)
 }
 
-type WithContentType = { __TYPE__: string }
-export function hasContentType(obj: unknown): obj is WithContentType {
-	return typeof obj === "object" && obj !== null && "__TYPE__" in obj
-}
-
-const isUuid = (input: unknown): input is string =>
-	typeof input === "string" && validateUuid(input)
-
-const uuidWithFallback = new t.Type<string, string, unknown>(
-	"UUID",
-	isUuid,
-	(u, c) => {
-		if (typeof u === "undefined") return t.success(uuid())
-		if (isUuid(u)) return t.success(u)
-		return t.failure(u, c, "Expected a valid UUID v4 string")
-	},
-	t.identity,
-)
-
-export function withKey<C extends t.Mixed>(codec: C) {
-	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
-}
-
 export type TraverseSliceContentFn = <
 	S extends SliceItemContent | SharedSliceItemContent,
 	D extends VariationFields | CompositeSlice | Group | NestableWidget,
@@ -90,6 +67,44 @@ export type TraverseWidgetContentFn<
 	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
 	| undefined
 
+export type TraverseWidgetContentWithModelFn<
+	ContentTransformMode extends "preserve" | "widen" = "preserve",
+> = <
+	C extends WidgetContent | undefined,
+	D extends NestableWidget | StaticSlices | Group | UID,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model: D
+	content: C
+}) =>
+	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
+	| undefined
+
+export type TraverseSliceContentWithModelFn = <
+	S extends SliceItemContent | SharedSliceItemContent | undefined,
+	D extends VariationFields | CompositeSlice | Group | NestableWidget,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model: D
+	content: S
+}) => S | SharedSliceItemContent | undefined
+
 export type ContentPathEntry = {
 	type:
 		| "CustomType"