@prismicio/types-internal 2.2.0-traverse.alpha-6 → 2.2.0-traverse.alpha-8

package/src/content/fields/nestable/NestableContent.ts

@@ -1,7 +1,6 @@
 import { isRight } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
-import type { NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx } from "../../LegacyContentCtx"
 import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
 import {
@@ -201,34 +200,3 @@ export const NestableLegacy = (ctx: LegacyContentCtx) => {
 		},
 	}
 }
-
-export function isValidStaticNestableContent(
-	content: NestableContent,
-	model?: NestableWidget,
-) {
-	if (!model) return false
-
-	switch (content.__TYPE__) {
-		// special case for no content so we can consider it valid no matter its model
-		case "EmptyContent":
-			return true
-		case "BooleanContent":
-			return model.type === "Boolean"
-		case "EmbedContent":
-			return model.type === "Embed"
-		case "FieldContent":
-			return content.type === model.type
-		case "GeoPointContent":
-			return model.type === "GeoPoint"
-		case "ImageContent":
-			return model.type === "Image"
-		case "IntegrationFieldsContent":
-			return model.type === "IntegrationFields"
-		case "LinkContent":
-			return model.type === "Link"
-		case "StructuredTextContent":
-			return model.type === "StructuredText"
-		case "SeparatorContent":
-			return model.type === "Separator"
-	}
-}

package/src/content/fields/nestable/RichTextContent/Blocks.ts

@@ -1,5 +1,5 @@
 import { either } from "fp-ts"
-import { isLeft, isRight } from "fp-ts/lib/Either"
+import { isRight } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
@@ -18,66 +18,54 @@ import {
 import { ImageContentView } from "../ImageContent"
 import { Link, LinkLegacy } from "../LinkContent"
 
-export const Meta = t.exact(
-	t.intersection([
-		t.partial({
-			data: t.unknown,
-		}),
-		t.type({
-			start: t.number,
-			end: t.number,
-			type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
-		}),
-	]),
-)
-export type Meta = t.TypeOf<typeof Meta>
-
-// export alias for code clarity
-export const Span = Meta
-export type Span = Meta
-
-export const ValidatedMetas = (linkCodec: LinkCodec) =>
-	new t.Type<Meta[], Meta[], unknown>(
-		"ValidatedMetas",
-		(metas): metas is Meta[] => Array.isArray(metas) && metas.every(Meta.is),
-		(metas: unknown, c) => {
-			if (Array.isArray(metas)) {
-				const res = metas
-					.reduce<Array<Meta>>((acc, maybeMeta) => {
-						const maybeDecodedMeta = Meta.decode(maybeMeta)
-						if (isRight(maybeDecodedMeta)) {
-							const meta = maybeDecodedMeta.right
-							// if it's an hyperlink it should have data validated as link otherwise we don't care and keep the meta
-							if (meta.data && meta.type === "hyperlink") {
-								const decoded = linkCodec.decode(meta.data)
-								if (isLeft(decoded)) return acc
-
-								return [...acc, { ...meta, data: decoded.right }]
-							} else if (meta.type !== "hyperlink") {
-								return [...acc, meta]
-							}
-						}
-						return acc
+const SpanFn = (linkCodec: typeof Link | typeof LinkLegacy) =>
+	t.exact(
+		t.intersection([
+			t.partial({
+				data: linkCodec,
+			}),
+			t.type({
+				start: t.number,
+				end: t.number,
+				type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
+			}),
+		]),
+	)
+
+export const Span = SpanFn(Link)
+export type Span = t.TypeOf<typeof Span>
+
+export const SpanLegacy = SpanFn(LinkLegacy)
+export type SpanLegacy = t.TypeOf<typeof SpanLegacy>
+
+export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) => {
+	type S = t.TypeOf<C>
+
+	return new t.Type<S[], S[], unknown>(
+		"ValidatedSpans",
+		(spans): spans is S[] => Array.isArray(spans) && spans.every(spanCodec.is),
+		(spans: unknown, c) => {
+			if (Array.isArray(spans)) {
+				const res = spans
+					.reduce<Array<S>>((acc, maybeSpan) => {
+						const decodedSpan = spanCodec.decode(maybeSpan)
+						return isRight(decodedSpan) ? [...acc, decodedSpan.right] : acc
 					}, [])
-					.sort((m1: Meta, m2: Meta) => m1.start - m2.start)
+					.sort((m1: S, m2: S) => m1.start - m2.start)
 				return t.success(res)
-			} else return t.failure(metas, c)
+			} else return t.failure(spans, c)
 		},
 		(m) => {
-			return m.reduce<Array<Meta>>((acc, meta) => {
-				if (meta.type === "hyperlink" && meta.data) {
-					// since the Span data are typed as unknown we have to redecode for type safety and then encode to either new format or legacy.
-					const decoded = linkCodec.decode(meta.data)
-					if (isLeft(decoded)) return acc
-
-					return [...acc, { ...meta, data: linkCodec.encode(decoded.right) }]
-				}
-				return [...acc, Meta.encode(meta)]
+			return m.reduce<Array<S>>((acc, meta) => {
+				return [...acc, spanCodec.encode(meta)]
 			}, [])
 		},
 	)
+}
 
-const ImageBlockCodec = (linkCodec: LinkCodec) =>
+const ImageBlockCodec = (linkCodec: typeof Link | typeof LinkLegacy) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -169,8 +157,9 @@ export function checkEmbedBlock(block: Block): block is EmbedBlock {
 	return block.type === RichTextNodeType.embed
 }
 
-type LinkCodec = typeof Link | typeof LinkLegacy
-const TextBlockCodec = (linkCodec: LinkCodec) =>
+const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -184,7 +173,7 @@ const TextBlockCodec = (linkCodec: LinkCodec) =>
 						text: t.string,
 					}),
 					t.partial({
-						spans: ValidatedMetas(linkCodec),
+						spans: ValidatedSpans(spanCodec),
 					}),
 				]),
 			}),
@@ -195,10 +184,11 @@ const TextBlockCodec = (linkCodec: LinkCodec) =>
 		]),
 	)
 
-export const TextBlock = TextBlockCodec(Link)
+/* These Text block will decode codec A and encode from codec B to A */
+export const TextBlock = TextBlockCodec(Span)
 export type TextBlock = t.TypeOf<typeof TextBlock>
 
-const TextBlockLegacy = TextBlockCodec(LinkLegacy)
+const TextBlockLegacy = TextBlockCodec(SpanLegacy)
 type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>
 
 const legacyBlockCodec = t.union([

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

@@ -8,10 +8,7 @@ import type {
 	TraverseSliceContentFn,
 	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
-import type {
-	CompositeSliceFields,
-	VariationFields,
-} from "../../../../customtypes"
+import type { CompositeSlice, VariationFields } from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
@@ -147,7 +144,7 @@ export function traverseCompositeSliceContent({
 	sliceKey: string
 	sliceName: string
 	content: CompositeSliceItemContent
-	model?: VariationFields | CompositeSliceFields | undefined
+	model?: VariationFields | CompositeSlice | undefined
 }) {
 	return (
 		transformWidget: TraverseWidgetContentFn,
@@ -159,7 +156,7 @@ export function traverseCompositeSliceContent({
 			const fieldDef = (() => {
 				return model?.type === "SharedSlice"
 					? model?.fields?.primary?.[fieldKey]
-					: model?.fields?.repeat?.[fieldKey]
+					: model?.["non-repeat"]?.[fieldKey]
 			})()
 
 			const transformedField = transformWidget({
@@ -173,7 +170,13 @@ export function traverseCompositeSliceContent({
 				content: fieldContent,
 			})
 			// Can happen if the transform function returns undefined to filter out a field
-			if (!transformedField || !isNestableContent(transformedField)) return acc
+			if (!transformedField) return acc
+			if (!isNestableContent(transformedField)) {
+				console.warn(
+					`Warn: Non nestable content with key [${fieldKey}] detected in a composite slice [${sliceName}] with key [${sliceKey}]`,
+				)
+				return acc
+			}
 			return {
 				...acc,
 				[fieldKey]: transformedField,
@@ -183,9 +186,7 @@ export function traverseCompositeSliceContent({
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "repeat", type: "items" }]),
 			model:
-				model?.type === "SharedSlice"
-					? model?.fields.items
-					: model?.fields.repeat,
+				model?.type === "SharedSlice" ? model?.fields.items : model?.repeat,
 			content: content.widget.repeat,
 		})(transformWidget)
 
@@ -219,9 +220,14 @@ export function migrateCompositeSlice(
 			variation: model.variationId,
 			primary: Object.entries(content.widget.nonRepeat).reduce(
 				(acc, [fieldKey, fieldContent]) => {
-					return model.fields.primary?.[fieldKey]
-						? { ...acc, [fieldKey]: fieldContent }
-						: acc
+					if (!model.fields.primary?.[fieldKey]) {
+						console.warn(
+							`The widget ${fieldKey} in the non-repeat zone of the composite slice [${model.sliceName}] with key [${content.key}] doesn't exist in the model.`,
+						)
+						return acc
+					}
+
+					return { ...acc, [fieldKey]: fieldContent }
 				},
 				{},
 			),
@@ -230,9 +236,13 @@ export function migrateCompositeSlice(
 					__TYPE__: "GroupItemContent",
 					value: groupItem.value.reduce<GroupItemContent["value"]>(
 						(acc, [fieldKey, fieldContent]) => {
-							return model.fields.items?.[fieldKey]
-								? acc.concat([[fieldKey, fieldContent]])
-								: acc
+							if (!model.fields.items?.[fieldKey]) {
+								console.warn(
+									`The widget ${fieldKey} in the repeat zone of the composite slice [${model.sliceName}] with key [${content.key}] doesn't exist in the model.`,
+								)
+								return acc
+							}
+							return acc.concat([[fieldKey, fieldContent]])
 						},
 						[],
 					),

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

@@ -174,7 +174,13 @@ export function traverseSharedSliceContent({
 				content: fieldContent,
 			})
 			// Can happen if the transform function returns undefined to filter out a field
-			if (!transformedField || !isNestableContent(transformedField)) return acc
+			if (!transformedField) return acc
+			if (!isNestableContent(transformedField)) {
+				console.warn(
+					`Warn: Non nestable content with key [${fieldKey}] detected in a shared slice [${sliceName}] with key [${sliceKey}]`,
+				)
+				return acc
+			}
 			return {
 				...acc,
 				[fieldKey]: transformedField,

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

@@ -168,7 +168,7 @@ export function migrateSimpleSlice(
 			__TYPE__: "SharedSliceContent",
 			variation: model.variationId,
 			primary: model.fields.primary?.[content.name]
-				? { [content.key]: content.widget }
+				? { [content.name]: content.widget }
 				: {},
 			items: [],
 		},

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

@@ -10,7 +10,7 @@ import {
 } from "../../../_internal/utils"
 import {
 	type StaticSlices,
-	CompositeSliceFields,
+	CompositeSlice,
 	Group,
 	isCompositeSlice,
 	isLegacySlice,
@@ -146,7 +146,7 @@ function findSliceModel(
 
 	const legacySliceModel = ():
 		| NestableWidget
-		| CompositeSliceFields
+		| CompositeSlice
 		| Group
 		| undefined => {
 		if (!defaultModel) return
@@ -154,10 +154,8 @@ function findSliceModel(
 		if (isCompositeSlice(defaultModel)) {
 			return {
 				type: "Slice",
-				fields: {
-					"non-repeat": defaultModel["non-repeat"] || {},
-					repeat: defaultModel.repeat || {},
-				},
+				"non-repeat": defaultModel["non-repeat"] || {},
+				repeat: defaultModel.repeat || {},
 			}
 		}
 		if (isLegacySlice(defaultModel)) {

package/src/customtypes/CustomType.ts

@@ -75,7 +75,7 @@ export function flattenWidgets(
 	)
 }
 
-export function flattenStaticWidgets(
+export function flattenSections(
 	customType: StaticCustomType,
 ): Array<[string, StaticWidget]> {
 	return Object.entries(customType.json).reduce(

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -1,6 +1,5 @@
 import * as t from "io-ts"
 
-import type { PickOnly } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
 import { NestableWidget } from "../nestable/NestableWidget"
@@ -33,11 +32,6 @@ export const CompositeSlice = t.exact(
 )
 export type CompositeSlice = t.TypeOf<typeof CompositeSlice>
 
-export type CompositeSliceFields = {
-	type: "Slice"
-	fields: PickOnly<CompositeSlice, "non-repeat" | "repeat">
-}
-
 export function isCompositeSlice(
 	slice: DynamicSlice | StaticSlice,
 ): slice is CompositeSlice {

package/src/customtypes/widgets/slices/SharedSlice.ts

@@ -1,7 +1,6 @@
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
-import type { PickOnly } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { NestableWidget } from "../nestable/NestableWidget"
 import type { SharedSliceRef } from "./SharedSliceRef"
@@ -30,11 +29,12 @@ export const Variation = t.exact(
 
 export type Variation = t.TypeOf<typeof Variation>
 
+// VariationFields is used exclusively for the slices migration, LegacySlice -> SharedSlice
 export type VariationFields = {
 	type: "SharedSlice"
 	sliceName: string
 	variationId: string
-	fields: PickOnly<Variation, "primary" | "items">
+	fields: Pick<Variation, "primary" | "items">
 }
 
 export const SharedSliceType = "SharedSlice"

package/src/import/converters/fields/nestable/Image.ts

@@ -5,22 +5,20 @@ import { withOptionals } from "../../../../utils/Objects"
 import type { ImageField, ImportImage } from "../../../validators"
 import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks"
 
-function convertImage<Input extends ImageField | ImportImageBlock>(
+export function convertImageView<Input extends ImageField | ImportImageBlock>(
 	inputImage: Input,
 	image: Asset,
 ) {
 	// We can do that because anyway all properties being read
 	const imageField: ImageField = {
 		...inputImage,
-		edit:
-			"edit" in inputImage
-				? inputImage.edit
-				: {
-						x: 0,
-						y: 0,
-						zoom: 1,
-				  },
-		dimensions: "dimensions" in inputImage ? inputImage.dimensions : {},
+		edit: {
+			x: 0,
+			y: 0,
+			zoom: 1,
+			...inputImage.edit,
+		},
+		dimensions: inputImage.dimensions ?? {},
 	}
 	return withOptionals<ImageContentView>(
 		{
@@ -64,7 +62,7 @@ function convertThumbnails(
 		(acc, [thumbnailName, thumbnail]) => {
 			return {
 				...acc,
-				[thumbnailName]: convertImage(
+				[thumbnailName]: convertImageView(
 					thumbnail,
 					getAssetOrThrow(assets)(thumbnail.id),
 				),
@@ -74,16 +72,6 @@ function convertThumbnails(
 	)
 }
 
-export const imageBlockConverter = (
-	imageBlock: ImportImageBlock,
-	assets: Record<Asset["id"], Asset | undefined>,
-): ImageContentView => {
-	return convertImage<ImportImageBlock>(
-		imageBlock,
-		getAssetOrThrow(assets)(imageBlock.id),
-	)
-}
-
 // All assets from `imageField` must be present in `assets`
 // If not then function will throw an error
 export const imageConverter = (
@@ -93,7 +81,7 @@ export const imageConverter = (
 	if (!imageField) return
 
 	return {
-		...convertImage<ImageField>(
+		...convertImageView<ImageField>(
 			imageField,
 			getAssetOrThrow(assets)(imageField.id),
 		),

package/src/import/converters/fields/nestable/RichText/embedBlock.ts

@@ -0,0 +1,17 @@
+import type { Embed } from "../../../../../common"
+import type { EmbedBlock } from "../../../../../content"
+import type { ImportEmbedBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { embedConverter } from "../Embed"
+
+export function embedBlockConverter(
+	block: ImportEmbedBlock,
+	embeds: Record<string, Embed | undefined>,
+): EmbedBlock {
+	const embedData = embedConverter(block.oembed, embeds)
+
+	if (!embedData) throw new Error("Failed to convert embed data")
+	return {
+		type: block.type,
+		data: embedData,
+	}
+}

package/src/import/converters/fields/nestable/RichText/imageBlock.ts

@@ -0,0 +1,17 @@
+import { Asset, getAssetOrThrow } from "../../../../../common"
+import type { ImageBlock } from "../../../../../content"
+import type { ImportImageBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { convertImageView } from "../Image"
+
+export function imageBlockConverter(
+	block: ImportImageBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageBlock {
+	return {
+		type: block.type,
+		data: convertImageView<ImportImageBlock>(
+			block,
+			getAssetOrThrow(assets)(block.id),
+		),
+	}
+}

package/src/import/converters/fields/nestable/RichText/index.ts

@@ -0,0 +1,23 @@
+import type { Asset, Embed } from "../../../../../common"
+import type { RichTextContent } from "../../../../../content"
+import { RichTextContentType } from "../../../../../content"
+import type { ImportRichText } from "../../../../validators"
+import { embedBlockConverter } from "./embedBlock"
+import { imageBlockConverter } from "./imageBlock"
+import { textBlockConverter } from "./textBlock"
+
+export const richTextConverter = (
+	richTextField: ImportRichText["value"],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): RichTextContent | undefined => {
+	if (richTextField === null) return
+	return {
+		__TYPE__: RichTextContentType,
+		value: richTextField.map((block) => {
+			if (block.type === "image") return imageBlockConverter(block, assets)
+			else if (block.type === "embed") return embedBlockConverter(block, embeds)
+			return textBlockConverter(block, assets)
+		}),
+	}
+}

package/src/import/converters/fields/nestable/RichText/textBlock.ts

@@ -0,0 +1,48 @@
+import type { Asset } from "../../../../../common"
+import type { TextBlock } from "../../../../../content"
+import type { ImportTextBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { linkConverter } from "../Link"
+
+export function textBlockConverter(
+	block: ImportTextBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): TextBlock {
+	return {
+		type: block.type,
+		content: {
+			text: block.text,
+			...(() => {
+				if (block.spans) {
+					const convertedSpans = spansConverter(block.spans, assets)
+					if (!convertedSpans) return {}
+
+					return { spans: convertedSpans }
+				}
+				return {}
+			})(),
+		},
+		...(block.direction ? { direction: block.direction } : {}),
+	}
+}
+
+function spansConverter(
+	spans: NonNullable<ImportTextBlock["spans"]>,
+	assets: Record<Asset["id"], Asset | undefined>,
+): TextBlock["content"]["spans"] {
+	return spans.map((span) => {
+		return {
+			type: span.type,
+			start: span.start,
+			end: span.end,
+			...(() => {
+				if (span.type === "hyperlink") {
+					const convertedLinkContent = linkConverter(span.data, assets)
+					if (!convertedLinkContent) return {}
+
+					return { data: convertedLinkContent?.value }
+				}
+				return {}
+			})(),
+		}
+	})
+}

package/src/import/converters/fields/nestable/index.ts

@@ -2,7 +2,7 @@ export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
 export * from "./Embed"
-export * from "./GeooPoint"
+export * from "./GeoPoint"
 export * from "./Image"
 export * from "./Link"
 export * from "./Nestable"

package/src/import/validators/fields/ImportContent.ts

@@ -10,14 +10,14 @@ export const ImportContent = <T extends FieldType, A, O = A>(
 	valueCodec: t.Type<A, O>,
 ) =>
 	new t.Type<{ type: T; value: A }, O>(
-		"ImportField",
+		`ImportField: ${valueCodec.name}`,
 		(u: unknown): u is { type: T; value: A } => {
 			if (!isObject(u)) return false
 			return type === u["type"] && valueCodec.is(u["value"])
 		},
-		(u: unknown) => {
+		(u: unknown, c) => {
 			return pipe(
-				valueCodec.decode(u),
+				valueCodec.validate(u, c),
 				either.map((decodedValue) => {
 					return {
 						type,

package/src/import/validators/fields/ImportSlices/ImportSlices.ts

@@ -3,7 +3,7 @@ import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
 import type { StaticSlices } from "../../../../customtypes"
-import { EmptyObjectOrElse } from "../../../../validators"
+import { EmptyArrayOrElse } from "../../../../validators"
 import { ImportContent } from "../ImportContent"
 import { SharedSlice } from "./SharedSlice"
 import {
@@ -16,13 +16,14 @@ export const ImportSlices = (staticSlices: StaticSlices) => {
 
 	// For now we only support the SharedSlice, however if we want to support more in the future
 	// we would have to change the codec here to something like this: t.array(t.union([ImportSharedSlice(sharedSlices), NewSliceCodec(newSliceCustomTypes)])).
-	const SlicesArrayCodec = t.array(SharedSlice(supportedSlices))
+	const SharedSliceCodec = SharedSlice(supportedSlices)
+	const SlicesArrayCodec = t.array(SharedSliceCodec)
 
 	return ImportContent(
 		"Slices",
-		EmptyObjectOrElse(
-			new t.Type<SharedSlice[]>(
-				"ImportSlices",
+		EmptyArrayOrElse(
+			new t.ArrayType<typeof SharedSliceCodec, SharedSlice[]>(
+				SlicesArrayCodec.name,
 				(u): u is SharedSlice[] => SlicesArrayCodec.is(u),
 				(u, c) => {
 					return pipe(
@@ -46,6 +47,7 @@ export const ImportSlices = (staticSlices: StaticSlices) => {
 					)
 				},
 				t.identity,
+				SharedSliceCodec,
 			),
 		),
 	)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.ts

@@ -83,8 +83,8 @@ export const SharedSliceContentEntry = (
 								errors.map((error) => {
 									const context = [
 										...c,
-										...error.context.filter(({ key }) => !!key), // We replace the "" key coming from ImportNestable decoder
 										{ key, actual: content, type: codec },
+										...error.context.slice(1), // We ignore the first context element with "" key coming from ImportNestable decoder
 									]
 
 									const updatedError: t.ValidationError = { ...error, context }