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

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

@@ -1,21 +1,252 @@
+import { either } from "fp-ts"
+import { isLeft } from "fp-ts/lib/Either"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import type { LegacyContentCtx } from "../../../LegacyContentCtx"
+import type {
+	ContentPath,
+	TraverseWidgetContentFn,
+} from "../../../../_internal/utils"
+import type { NestableWidget, NestedGroup } from "../../../../customtypes"
 import {
-	GroupContent,
-	GroupItemContentType,
-	GroupItemLegacy,
-} from "../../GroupContent"
-import { NestableContent } from "../../nestable"
+	FieldOrSliceType,
+	getFieldCtx,
+	LegacyContentCtx,
+	WithTypes,
+} from "../../../LegacyContentCtx"
+import { hasContentType } from "../../../utils"
+import { GroupContentType, GroupItemContentType } from "../../GroupContent"
+import {
+	isNestableContent,
+	NestableContent,
+	NestableLegacy,
+} from "../../nestable"
+
+/**
+ * This is essentially a copy of `GroupItemContent` that doesn't support
+ * nested groups to keep accurate content types for legacy slice.
+ */
+const RepeatableWidgetItemContent = t.strict({
+	__TYPE__: t.literal(GroupItemContentType),
+	value: t.array(t.tuple([t.string, NestableContent])),
+})
+export type RepeatableWidgetItemContent = t.TypeOf<
+	typeof RepeatableWidgetItemContent
+>
+
+const itemLegacyReader = t.record(t.string, t.unknown)
+type RepeatableWidgetItemLegacy = t.TypeOf<typeof itemLegacyReader>
+
+/**
+ * This is essentially a copy of `GroupItemLegacy` that doesn't support
+ * nested groups to keep accurate content types for legacy slice.
+ */
+const RepeatableWidgetItemLegacy = (ctx: LegacyContentCtx) => {
+	return new t.Type<
+		RepeatableWidgetItemContent,
+		WithTypes<RepeatableWidgetItemLegacy>
+	>(
+		"RepeatableWidgetItemLegacy",
+		(u): u is RepeatableWidgetItemContent =>
+			hasContentType(u) && u.__TYPE__ === GroupItemContentType,
+		(u) => {
+			const parsed = pipe(
+				itemLegacyReader.decode(u),
+				either.map((items) => {
+					const parsedItems = Object.entries(items).reduce<
+						Array<[string, NestableContent]>
+					>((acc, [itemKey, itemValue]) => {
+						const itemCtx = getFieldCtx(itemKey, ctx)
+						const result = NestableLegacy(itemCtx).decode(itemValue)
+						if (!result) return acc
+
+						if (isLeft(result)) return acc
+						return [...acc, [itemKey, result.right]]
+					}, [])
+
+					return {
+						value: parsedItems,
+						__TYPE__: GroupItemContentType,
+					}
+				}),
+			)
+			return parsed
+		},
+		(item) => {
+			return item.value.reduce<WithTypes<RepeatableWidgetItemLegacy>>(
+				(acc, [key, value]) => {
+					const itemCtx = getFieldCtx(key, ctx)
+					const encoded = NestableLegacy(itemCtx).encode(value)
+					if (!encoded) return acc
+
+					return {
+						content: { ...acc.content, [key]: encoded.content },
+						types: { ...acc.types, ...encoded.types },
+					}
+				},
+				{ content: {}, types: {} },
+			)
+		},
+	)
+}
+
+/**
+ * This is essentially a copy of `GroupLegacy` that doesn't support
+ * nested groups to keep accurate content types for legacy slice.
+ */
+type RepeatableWidgetLegacy = Array<RepeatableWidgetItemLegacy>
+export const RepeatableWidgetLegacy = (ctx: LegacyContentCtx) => {
+	const codecDecode = t.array(
+		t.union([t.null, RepeatableWidgetItemLegacy(ctx)]),
+	)
+	const codecEncode = t.array(RepeatableWidgetItemLegacy(ctx))
+
+	return new t.Type<
+		RepeatableWidgetContent,
+		WithTypes<RepeatableWidgetLegacy>,
+		unknown
+	>(
+		"RepeatableWidgetLegacy",
+		isRepeatableWidgetContent,
+		(items) => {
+			return pipe(
+				codecDecode.decode(items),
+				either.map((parsedItems) => {
+					return {
+						value: parsedItems.map((i) => {
+							if (i === null) {
+								return { __TYPE__: GroupItemContentType, value: [] }
+							} else return i
+						}),
+						__TYPE__: GroupContentType,
+					}
+				}),
+			)
+		},
+		(g: RepeatableWidgetContent) => {
+			const res = codecEncode.encode(g.value)
+			return {
+				content: res.map((block) => block.content),
+				types: res.reduce<Record<string, FieldOrSliceType>>(
+					(acc, block) => {
+						return { ...acc, ...block.types }
+					},
+					{ [ctx.keyOfType]: "Group" },
+				),
+			}
+		},
+	)
+}
+
+/**
+ * This is essentially a copy of `isGroupContent` that doesn't support
+ * nested groups to keep accurate content types for legacy slice.
+ */
+export const isRepeatableWidgetContent = (
+	u: unknown,
+): u is RepeatableWidgetContent =>
+	hasContentType(u) && u.__TYPE__ === GroupContentType
+
+export const RepeatableWidgetContent = t.strict({
+	__TYPE__: t.literal(GroupContentType),
+	value: t.array(RepeatableWidgetItemContent),
+})
+export type RepeatableWidgetContent = t.TypeOf<typeof RepeatableWidgetContent>
+
+/**
+ * This is essentially a copy of `traverseGroupContent` that doesn't support
+ * nested groups to keep accurate content types for legacy slice.
+ */
+export function traverseRepeatableWidgetContent({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	content: RepeatableWidgetContent
+	model?: NestedGroup | undefined
+}) {
+	return (
+		transform: TraverseWidgetContentFn,
+	): RepeatableWidgetContent | undefined => {
+		const repeatableWidgetItems = traverseRepeatableWidgetItemsContent({
+			path,
+			model: model?.config?.fields,
+			content: content.value,
+		})(transform)
+
+		return transform({
+			path,
+			key,
+			apiId,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				value: repeatableWidgetItems,
+			},
+		})
+	}
+}
+
+/**
+ * This is essentially a copy of `traverseGroupItemContent` that doesn't support
+ * nested groups to keep accurate content types for legacy slice.
+ */
+export function traverseRepeatableWidgetItemsContent({
+	path,
+	model,
+	content,
+}: {
+	path: ContentPath
+	content: Array<RepeatableWidgetItemContent>
+	model?: Record<string, NestableWidget> | undefined
+}) {
+	return (
+		transform: TraverseWidgetContentFn,
+	): Array<RepeatableWidgetItemContent> => {
+		return content.map((repeatableWidgetItem, index) => {
+			const repeatableWidgetItemPath = path.concat([
+				{ key: index.toString(), type: "GroupItem" },
+			])
+
+			const repeatableWidgetItemFields = repeatableWidgetItem.value.reduce<
+				RepeatableWidgetItemContent["value"]
+			>((acc, [fieldKey, fieldContent]) => {
+				const fieldDef = model?.[fieldKey]
+
+				const transformedField = transform({
+					path: repeatableWidgetItemPath.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 || !isNestableContent(transformedField))
+					return acc
+
+				return acc.concat([[fieldKey, transformedField]])
+			}, [])
+
+			return {
+				__TYPE__: repeatableWidgetItem.__TYPE__,
+				value: repeatableWidgetItemFields,
+			}
+		})
+	}
+}
 
 export const RepeatableWidgetsLegacy = (ctx: LegacyContentCtx) => {
-	return t.array(GroupItemLegacy(ctx))
+	return t.array(RepeatableWidgetItemLegacy(ctx))
 }
 
-const RepeatableWidget = t.tuple([
-	t.string,
-	t.union([NestableContent, GroupContent]),
-])
+const RepeatableWidget = t.tuple([t.string, NestableContent])
 const RepeatableWidgetsBlock = t.strict({
 	__TYPE__: t.literal(GroupItemContentType),
 	value: t.array(RepeatableWidget),

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

@@ -20,18 +20,18 @@ import {
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
-import {
-	isGroupContent,
-	traverseGroupContent,
-	traverseGroupItemsContent,
-} from "../../GroupContent"
+import { isGroupContent, traverseGroupContent } from "../../GroupContent"
 import { isNestableContent } from "../../nestable"
 import {
 	repeatableContentWithDefaultNestableContentValues,
 	withDefaultSlicePrimaryContentValues,
 } from "../../withDefaultValues"
 import type { SharedSliceItemContent } from "../SliceItem"
-import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
+import {
+	RepeatableWidgets,
+	RepeatableWidgetsLegacy,
+	traverseRepeatableWidgetItemsContent,
+} from "./RepeatableContent"
 import {
 	isSlicePrimaryContent,
 	SlicePrimaryContent,
@@ -245,7 +245,7 @@ export function traverseSharedSliceContent({
 			}
 		}, {})
 
-		const items = traverseGroupItemsContent({
+		const items = traverseRepeatableWidgetItemsContent({
 			path: path.concat([{ key: "items", type: "items" }]),
 			model: model?.fields.items,
 			content: content.widget.items,

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

@@ -6,18 +6,11 @@ import type {
 	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
 import type {
-	Group,
 	NestableWidget,
+	NestedGroup,
 	VariationFields,
 } from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import {
-	GroupContent,
-	GroupItemContent,
-	GroupLegacy,
-	isGroupContent,
-	traverseGroupContent,
-} from "../../GroupContent"
 import {
 	isNestableContent,
 	NestableContent,
@@ -27,24 +20,35 @@ import type {
 	SharedSliceItemContent,
 	SimpleSliceItemContent,
 } from "../SliceItem"
+import {
+	isRepeatableWidgetContent,
+	RepeatableWidgetContent,
+	RepeatableWidgetItemContent,
+	RepeatableWidgetLegacy,
+	traverseRepeatableWidgetContent,
+} from "./RepeatableContent"
 
-export const SimpleSliceContent = t.union([NestableContent, GroupContent])
+export const SimpleSliceContent = t.union([
+	NestableContent,
+	RepeatableWidgetContent,
+])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
 
 export const isSimpleSliceContent = (u: unknown): u is SimpleSliceContent =>
-	isNestableContent(u) || isGroupContent(u)
+	isNestableContent(u) || isRepeatableWidgetContent(u)
 
 export const SimpleSliceLegacy = (ctx: LegacyContentCtx) => {
 	return {
 		decode: (() => {
-			if (ctx.fieldType === "Group") return GroupLegacy(ctx).decode.bind(null)
+			if (ctx.fieldType === "Group")
+				return RepeatableWidgetLegacy(ctx).decode.bind(null)
 			return NestableLegacy(ctx).decode.bind(null)
 		})(),
 
 		encode: (value: SimpleSliceContent) => {
 			switch (value.__TYPE__) {
 				case "GroupContentType":
-					return GroupLegacy(ctx).encode(value)
+					return RepeatableWidgetLegacy(ctx).encode(value)
 				default:
 					return NestableLegacy(ctx).encode(value)
 			}
@@ -63,15 +67,15 @@ export function traverseSimpleSliceContent({
 	sliceKey: string
 	sliceName: string
 	content: SimpleSliceItemContent
-	model?: VariationFields | Group | NestableWidget | undefined
+	model?: VariationFields | NestedGroup | NestableWidget | undefined
 }) {
 	return (
 		transformWidget: TraverseWidgetContentFn,
 		transformSlice: TraverseSliceContentFn,
 	): SharedSliceItemContent | SimpleSliceItemContent | undefined => {
-		if (isGroupContent(content.widget)) {
-			const convertedGroupWidget: GroupContent | undefined =
-				traverseGroupContent({
+		if (isRepeatableWidgetContent(content.widget)) {
+			const convertedGroupWidget: RepeatableWidgetContent | undefined =
+				traverseRepeatableWidgetContent({
 					path,
 					key: content.key,
 					apiId: content.name,
@@ -150,7 +154,7 @@ export function migrateSimpleSlice(
 				items: content.widget.value.map((groupItem) => {
 					return {
 						__TYPE__: "GroupItemContent",
-						value: groupItem.value.reduce<GroupItemContent["value"]>(
+						value: groupItem.value.reduce<RepeatableWidgetItemContent["value"]>(
 							(acc, [fieldKey, fieldContent]) => {
 								return model.fields.items?.[fieldKey]
 									? acc.concat([[fieldKey, fieldContent]])

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

@@ -47,6 +47,7 @@ export const SliceContent = t.union([
 export type SliceContent = t.TypeOf<typeof SliceContent>
 
 export * from "./CompositeSliceContent"
+export * from "./RepeatableContent"
 export * from "./SharedSliceContent"
 export * from "./SimpleSliceContent"
 export * from "./SlicePrimaryContent"

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

@@ -11,11 +11,11 @@ import {
 import {
 	type StaticSlices,
 	CompositeSlice,
-	Group,
 	isCompositeSlice,
 	isLegacySlice,
 	isStaticSharedSlice,
 	NestableWidget,
+	NestedGroup,
 	SharedSlice,
 	VariationFields,
 } from "../../../customtypes"
@@ -177,7 +177,7 @@ function findSliceModel(
 	const legacySliceModel = ():
 		| NestableWidget
 		| CompositeSlice
-		| Group
+		| NestedGroup
 		| undefined => {
 		if (!defaultModel) return
 

package/src/validators/function.ts

@@ -19,17 +19,7 @@ export function refineType<A, O, I>(
 		(u, c) =>
 			pipe(
 				type.validate(u, c),
-				either.chain((v) => {
-					try {
-						return pred(v) ? t.success(v) : t.failure(u, c)
-					} catch (error) {
-						return t.failure(
-							u,
-							c,
-							error instanceof Error ? error.message : String(error),
-						)
-					}
-				}),
+				either.chain((v) => (pred(v) ? t.success(v) : t.failure(u, c))),
 			),
 		type.encode,
 	)