@prismicio/types-internal 2.2.0-traverse.alpha-12 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-traverse.alpha-12",
+	"version": "2.2.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/import/converters/Document.ts

@@ -2,7 +2,11 @@ import type { Asset, Embed } from "../../common"
 import type { Document, WidgetContent } from "../../content"
 import type { ImportDocument } from "../validators"
 import type { ImportField } from "../validators/fields/ImportField"
-import { convertNestableWidget, importSlicesConverter } from "./fields"
+import {
+	convertNestableWidget,
+	importGroupConverter,
+	importSlicesConverter,
+} from "./fields"
 
 export function convertImportToContent(
 	document: ImportDocument,
@@ -26,6 +30,8 @@ function convertWidget(
 	switch (field.type) {
 		case "Slices":
 			return importSlicesConverter(field.value, assets, embeds)
+		case "Group":
+			return importGroupConverter(field.value, assets, embeds)
 		default:
 			return convertNestableWidget(field, assets, embeds)
 	}

package/src/import/converters/fields/Group.ts

@@ -0,0 +1,18 @@
+import type { Asset, Embed } from "../../../common"
+import type { GroupContent } from "../../../content"
+import { GroupContentType } from "../../../content"
+import type { ImportGroup } from "../../validators/fields/ImportGroup"
+import { repeatableZoneConverter } from "./RepeatableZone"
+
+export const importGroupConverter = (
+	field: ImportGroup["value"],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): GroupContent | undefined => {
+	if (field === null) return
+
+	return {
+		__TYPE__: GroupContentType,
+		value: repeatableZoneConverter(field, assets, embeds),
+	}
+}

package/src/import/converters/fields/RepeatableZone.ts

@@ -0,0 +1,19 @@
+import type { Asset, Embed } from "../../../common"
+import { GroupItemContentType, NestableContent } from "../../../content"
+import type { RepeatableZone } from "../../validators"
+import { repeatableZoneItemConverter } from "./RepeatableZoneItem"
+
+export const repeatableZoneConverter = (
+	zone: RepeatableZone,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+) => {
+	return zone.map((item) => {
+		const groupContent: Record<string, NestableContent> =
+			repeatableZoneItemConverter(item, assets, embeds)
+		return {
+			__TYPE__: GroupItemContentType,
+			value: Object.entries(groupContent),
+		}
+	})
+}

package/src/import/converters/fields/RepeatableZoneItem.ts

@@ -0,0 +1,32 @@
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+import * as R from "fp-ts/Record"
+
+import type { Asset, Embed } from "../../../common"
+import type { NestableContent } from "../../../content"
+import type { RepeatableZoneItem } from "../../validators"
+import { convertNestableWidget } from "./nestable"
+
+/**
+ * Converts the RepeatableZoneItem which is a record of widget keys and ImportNestable values to a record of widget keys and NestableContent values.
+ *
+ * @param content a single RepeatableZoneItem
+ * @param assets assets that are required for a conversion of a nestable widget
+ * @param embeds embeds that are required for a conversion of a nestable widget
+ */
+export const repeatableZoneItemConverter = (
+	content: RepeatableZoneItem,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): Record<string, NestableContent> =>
+	pipe(
+		content,
+		// convertNestableWidget can theoretically return undefined, so we need to filter out those values
+		R.filterMap((contentValue) =>
+			pipe(
+				contentValue,
+				(content) => content && convertNestableWidget(content, assets, embeds),
+				O.fromNullable,
+			),
+		),
+	)

package/src/import/converters/fields/Slices/SharedSliceContent.ts

@@ -1,78 +1,9 @@
-import { pipe } from "fp-ts/function"
-import * as O from "fp-ts/Option"
-import * as R from "fp-ts/Record"
-
 import type { Asset, Embed } from "../../../../common"
-import type { NestableContent, SharedSliceContent } from "../../../../content"
-import {
-	GroupItemContentType,
-	SharedSliceContentType,
-} from "../../../../content"
-import type {
-	SharedSlice as ImportSharedSlice,
-	SharedSliceContent as ImportSharedSliceContent,
-} from "../../../validators/fields/ImportSlices/SharedSlice"
-import { convertNestableWidget } from "../nestable"
-
-/**
- * Converts the ImportSharedSliceContent which is a record of widget keys and ImportNestable values to a record of widget keys and NestableContent values.
- *
- * @param content a single ImportSharedSliceContent
- * @param assets assets that are required for a conversion of a nestable widget
- * @param embeds embeds that are required for a conversion of a nestable widget
- */
-const sharedSliceContentConverter = (
-	content: ImportSharedSliceContent,
-	assets: Record<Asset["id"], Asset | undefined>,
-	embeds: Record<string, Embed | undefined>,
-): Record<string, NestableContent> =>
-	pipe(
-		content,
-		// convertNestableWidget can theoretically return undefined, so we need to filter out those values
-		R.filterMap((contentValue) =>
-			pipe(
-				contentValue,
-				(content) => convertNestableWidget(content, assets, embeds),
-				O.fromNullable,
-			),
-		),
-	)
-
-/**
- * Converts a list of items to a list of repeatable widgets.
- * Each ImportSharedSliceContent element is a record of fields, but in the content model it is represented as a list of tuples (key, value)
- *
- * For example, given the following slice content:
- *  {
- *  	"slice_text": (ImportNestable),
- *  	"slice_number": (ImportNestable),
- *  }
- *
- *  has to be converted to:
- *
- *  {
- *      __TYPE__: "GroupItemContentType",
- *      value: [
- *      	["slice_text", (NestableContent)],
- *      	["slice_number", (NestableContent)],
- *      ]
- *  }
- *
- *  @param items list of items to be converted
- *  @param assets assets that are required for a conversion of a nestable widget
- */
-const itemsConverter = (
-	items: ImportSharedSliceContent[],
-	assets: Record<Asset["id"], Asset | undefined>,
-	embeds: Record<string, Embed | undefined>,
-): SharedSliceContent["items"] =>
-	items.map((item) =>
-		pipe(
-			sharedSliceContentConverter(item, assets, embeds),
-			(record) => Object.entries(record),
-			(entries) => ({ __TYPE__: GroupItemContentType, value: entries }),
-		),
-	)
+import type { SharedSliceContent } from "../../../../content"
+import { SharedSliceContentType } from "../../../../content"
+import type { SharedSlice as ImportSharedSlice } from "../../../validators/fields/ImportSlices/SharedSlice"
+import { repeatableZoneConverter } from "../RepeatableZone"
+import { repeatableZoneItemConverter } from "../RepeatableZoneItem"
 
 /**
  * Builds SharedSliceContent model from ImportSharedSlice
@@ -87,8 +18,10 @@ export const importSharedSliceContentConverter = (
 ): SharedSliceContent => ({
 	__TYPE__: SharedSliceContentType,
 	primary: field.primary
-		? sharedSliceContentConverter(field.primary, assets, embeds)
+		? repeatableZoneItemConverter(field.primary, assets, embeds)
 		: {},
-	items: field.items ? itemsConverter(field.items, assets, embeds) : [],
+	items: field.items
+		? repeatableZoneConverter(field.items, assets, embeds)
+		: [],
 	variation: field.variation,
 })

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

@@ -1,3 +1,4 @@
+export * from "./Group"
 export * from "./nestable"
 export * from "./Slices"
 export * from "./UID"

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

@@ -1,8 +1,9 @@
 import type { StaticWidget } from "../../../customtypes"
+import { ImportGroup } from "./ImportGroup"
 import { ImportSlices } from "./ImportSlices"
 import { ImportNestable } from "./nestable"
 
-export type ImportField = ImportSlices | ImportNestable
+export type ImportField = ImportSlices | ImportNestable | ImportGroup
 
 export const ImportField = {
 	is(u: unknown): u is ImportField {
@@ -20,8 +21,12 @@ export const ImportField = {
 						codec: ImportSlices(field),
 						result: ImportSlices(field).decode(content),
 					}
-				case "Choice":
 				case "Group":
+					return {
+						codec: ImportGroup(field),
+						result: ImportGroup(field).decode(content),
+					}
+				case "Choice":
 					throw new Error(`Unsupported type of field ${field.type}`)
 				default:
 					return ImportNestable.decode(field)(content)

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

@@ -0,0 +1,45 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import type { Group } from "../../../customtypes"
+import { EmptyArrayOrElse } from "../../../validators"
+import { withCustomError } from "../../../validators/function"
+import { ImportContent } from "./ImportContent"
+import { RepeatableZone } from "./RepeatableZone"
+
+export const ImportGroupValue = (groupCustomType?: Group) => {
+	const fieldsModel = groupCustomType?.config?.fields ?? {}
+	const groupArrayCodec = RepeatableZone(fieldsModel)
+
+	return withCustomError(
+		new t.Type<RepeatableZone>(
+			groupArrayCodec.name,
+			groupArrayCodec.is,
+			(u, c) =>
+				pipe(
+					groupArrayCodec.validate(u, c),
+					E.chain((groups) => {
+						if (
+							groupCustomType?.config?.repeat === false &&
+							groups.length > 1
+						) {
+							return t.failure(
+								groups,
+								c,
+								"The custom type for this group field does not allow multiple group items",
+							)
+						}
+						return t.success(groups)
+					}),
+				),
+			t.identity,
+		),
+		() => "The group field value must be an array",
+	)
+}
+
+export const ImportGroup = (groupCustomType?: Group) =>
+	ImportContent("Group", EmptyArrayOrElse(ImportGroupValue(groupCustomType)))
+
+export type ImportGroup = t.TypeOf<ReturnType<typeof ImportGroup>>

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

@@ -4,10 +4,10 @@ import * as t from "io-ts"
 
 import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes"
 import { NonEmptyString, String } from "../../../../../validators"
-import { withCustomError } from "../../../../../validators/function"
+import { RepeatableZone } from "../../RepeatableZone"
+import { RepeatableZoneItem } from "../../RepeatableZoneItem"
 import {
 	OptionalSharedSliceId,
-	SharedSliceContent,
 	SharedSliceId,
 	SharedSliceType,
 	SharedSliceVariation,
@@ -18,8 +18,8 @@ export type SharedSlice = {
 	slice_type: string
 	name: string
 	variation: string
-	primary: SharedSliceContent | null | undefined
-	items: SharedSliceContent[] | null | undefined
+	primary: RepeatableZoneItem | null | undefined
+	items: RepeatableZone | null | undefined
 	slice_label: string | null | undefined
 	version: string | null | undefined
 }
@@ -70,22 +70,10 @@ export const SharedSlice = (sharedSlices: SharedSliceCustomType[]) =>
 						// We validate the 'primary' and 'items' content fields, for which we need the Variation custom type retrieved in the previous step
 						t
 							.partial({
-								primary: SharedSliceContent(
-									decoded.slice_type.slice_type,
-									"primary",
+								primary: RepeatableZoneItem(
 									decoded.variation.data.primary ?? {},
 								),
-								// We need to use this wrapper codec instead of using t.array(SharedSliceContent) directly in order to get proper custom error messages
-								items: withCustomError(
-									t.array(
-										SharedSliceContent(
-											decoded.slice_type.slice_type,
-											"items",
-											decoded.variation.data.items ?? {},
-										),
-									),
-									() => "The value must be an array",
-								),
+								items: RepeatableZone(decoded.variation.data.items ?? {}),
 							})
 							.validate(u, c),
 						E.map(({ primary, items }) => ({ ...decoded, primary, items })),

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

@@ -1,5 +1,4 @@
 export * from "./OptionalSharedSliceId"
-export * from "./SharedSliceContent"
 export * from "./SharedSliceId"
 export * from "./SharedSliceType"
 export * from "./SharedSliceVariation"

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

@@ -0,0 +1,21 @@
+import * as t from "io-ts"
+
+import type { WidgetKey } from "../../../common"
+import type { NestableWidget } from "../../../customtypes"
+import { withCustomError } from "../../../validators/function"
+import { RepeatableZoneItem } from "./RepeatableZoneItem"
+
+export type RepeatableZone = t.TypeOf<ReturnType<typeof RepeatableZone>>
+
+/**
+ * A custom type for a repeatable zone. This type of structure can be found 'items' field of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+export const RepeatableZone = (
+	fieldModels: Record<WidgetKey, NestableWidget>,
+) =>
+	withCustomError(
+		t.array(RepeatableZoneItem(fieldModels)),
+		() => "The repeatable zone value must be an array",
+	)

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

@@ -0,0 +1,64 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { WidgetKey } from "../../../common"
+import type { NestableWidget } from "../../../customtypes"
+import { withCustomError } from "../../../validators/function"
+import { ImportNestable } from "./nestable"
+
+export type RepeatableZoneItem = Record<WidgetKey, ImportNestable>
+
+/**
+ * A custom type for an item of a repeatable zone. This type of structure can be found in the 'primary' and 'items' fields of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+export const RepeatableZoneItem = (
+	fieldModels: Record<WidgetKey, NestableWidget>,
+) =>
+	new t.Type<RepeatableZoneItem>(
+		"RepeatableZoneItem",
+		(u): u is RepeatableZoneItem =>
+			t.record(WidgetKey, t.unknown).is(u) &&
+			Object.values(u).reduce<boolean>(
+				(acc, value) => acc && ImportNestable.is(value),
+				true,
+			),
+		(u, c) => {
+			const codecEntries = Object.entries(fieldModels).map(
+				([key, model]) => [key, ImportNestable.getCodec(model)] as const,
+			)
+
+			const groupCodec = withCustomError(
+				t.partial({
+					...Object.fromEntries(codecEntries),
+				}),
+				() => "The value must be an object",
+			)
+
+			return pipe(
+				groupCodec.validate(u, c),
+				E.chain((decodedContent) => {
+					// Validate if all fields are present in the model
+					const keys = Object.keys(decodedContent)
+					const errors: t.Errors = keys.flatMap((key) =>
+						fieldModels[key]
+							? []
+							: [
+									{
+										value: decodedContent[key],
+										context: c,
+										message: `The field '${key}' is not defined in the custom type`,
+									},
+							  ],
+					)
+
+					return errors.length > 0
+						? t.failures(errors)
+						: t.success(decodedContent as RepeatableZoneItem) // We can never have a key with decoded value 'undefined' so we can ignore the type derived from t.partial
+				}),
+			)
+		},
+		t.identity,
+	)

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

@@ -1,2 +1,4 @@
 export * from "./nestable"
+export * from "./RepeatableZone"
+export * from "./RepeatableZoneItem"
 export * from "./UID"

package/src/import/validators/fields/nestable/Nestable.ts

@@ -26,6 +26,37 @@ export type ImportNestable =
 	| ImportImage
 	| ImportRichText
 
+const getCodecOrThrow = (field: NestableWidget) => {
+	switch (field.type) {
+		case "Boolean":
+			return ImportBoolean
+		case "Color":
+			return ImportColor
+		case "Number":
+			return ImportNumber(field)
+		case "Select":
+			return ImportSelect(field)
+		case "Text":
+			return ImportText
+		case "Date":
+			return ImportDate
+		case "Timestamp":
+			return ImportTimestamp
+		case "Embed":
+			return ImportEmbed
+		case "Link":
+			return ImportLink
+		case "Image":
+			return ImportImage(field)
+		case "GeoPoint":
+			return ImportGeoPoint
+		case "StructuredText":
+			return ImportRichText(field)
+		default:
+			throw new Error(`Unsupported type of nestable field ${field.type}`)
+	}
+}
+
 export const ImportNestable = {
 	is(u: unknown): u is ImportNestable {
 		return (
@@ -45,41 +76,13 @@ export const ImportNestable = {
 	},
 	decode: (field: NestableWidget) => {
 		return (content: unknown) => {
-			const codec = (() => {
-				switch (field.type) {
-					case "Boolean":
-						return ImportBoolean
-					case "Color":
-						return ImportColor
-					case "Number":
-						return ImportNumber(field)
-					case "Select":
-						return ImportSelect(field)
-					case "Text":
-						return ImportText
-					case "Date":
-						return ImportDate
-					case "Timestamp":
-						return ImportTimestamp
-					case "Embed":
-						return ImportEmbed
-					case "Link":
-						return ImportLink
-					case "Image":
-						return ImportImage(field)
-					case "GeoPoint":
-						return ImportGeoPoint
-					case "StructuredText":
-						return ImportRichText(field)
-					default:
-						throw new Error(`Unsupported type of nestable field ${field.type}`)
-				}
-			})()
-
+			const codec = getCodecOrThrow(field)
 			return {
 				codec,
 				result: codec.decode(content),
 			}
 		}
 	},
+
+	getCodec: getCodecOrThrow,
 }

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

@@ -1,64 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { WidgetKey } from "../../../../../../../common"
-import type { NestableWidget } from "../../../../../../../customtypes"
-import { combineValidationResults } from "../../../../../../../utils/io-ts"
-import { withCustomError } from "../../../../../../../validators/function"
-import type { ImportNestable } from "../../../../nestable"
-import { SharedSliceContentEntry } from "./SharedSliceContentEntry"
-
-/**
- * Represents the object in the 'primary' field or a single item in the 'items' array in the SharedSlice.
- */
-export type SharedSliceContent = Record<WidgetKey, ImportNestable>
-
-/**
- * Builds the decoder for a single entry in the 'primary' field or a single item in the 'items' array in the SharedSlice.
- *
- * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- * @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
- * @constructor
- */
-export const SharedSliceContent = (
-	sliceName: string,
-	sliceContentField: "primary" | "items",
-	sliceFieldModels: Record<WidgetKey, NestableWidget>,
-) =>
-	new t.Type<SharedSliceContent, SharedSliceContent, unknown>(
-		"SharedSliceContent",
-		(u): u is SharedSliceContent => t.record(WidgetKey, t.unknown).is(u),
-		(u, c) =>
-			pipe(
-				// We first decode the raw content object in the shape of Record<WidgetKey, unknown>
-				withCustomError(
-					t.UnknownRecord,
-					() => "The value must be an object",
-				).validate(u, c),
-				E.chain((rawContent) =>
-					pipe(
-						// We split the object into entries because there is no easy other way to decode each value with a different codec
-						Object.entries(rawContent).map((entry) =>
-							SharedSliceContentEntry(
-								sliceName,
-								sliceContentField,
-								sliceFieldModels,
-							).validate(entry, c),
-						),
-						// We get a validation result for each entry in the content object (t.Validation<SharedSliceContentEntry>[]),
-						// however we want to get a single validation result for the whole array of entries (t.Validation<SharedSliceContentEntry[]>).
-						combineValidationResults,
-						// We build the object back from entries if all decoded successfully
-						E.map((entries) =>
-							entries.reduce(
-								(acc, [key, value]) => ({ ...acc, [key]: value }),
-								{},
-							),
-						),
-					),
-				),
-			),
-		t.identity,
-	)

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

@@ -1,100 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import { WidgetKey } from "../../../../../../../common"
-import type { NestableWidget } from "../../../../../../../customtypes"
-import { ImportNestable } from "../../../../nestable"
-import { SharedSliceContentErrors } from "./errors"
-
-export type SharedSliceContentEntry = [WidgetKey, ImportNestable]
-/**
- * Represents a single entry in the 'primary' field or a single entry in an item in the 'items' array in the SharedSlice. It is used to build the SharedSliceContent type from entries of the import object.
- *
- * For example, given the following slice:
- * 	{
- *  	"slice_type": "my_slice",
- *  	"variation": "default",
- *      "primary": {
- *      	"slice_text": "abc", // This is one entry
- *          "slice_text2": "def: // This is another entry
- *       },
- *       "items": [
- *       	   {
- *             		"slice_number1": 0, // This is one entry
- *             		"slice_number2": 1	// And this is yet another entry
- *             }
- *       ]
- *  }
- *
- *  The 'primary' object is converted to following entries to be decoded:
- *  [
- *      ["slice_text", "abc"],
- *      ["slice_text2", "def"]
- *  ]
- *  and the first item in the 'items' array is converted to following entries to be decoded:
- *  [
- *    ["slice_number1", 0],
- *    ["slice_number2", 1]
- *  ]
- *
- *  We decode them as separate entries because each of the values might require a different codec as per what is specified in the SharedSlice custom type.
- *  In this way we save on the decoding performance in comparison to a scenario where we would decode the whole content object as a record with a union type decoder for each value.
- *
- *  @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- *  @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- *  @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
- */
-export const SharedSliceContentEntry = (
-	sliceName: string,
-	sliceContentField: "primary" | "items",
-	sliceFieldModels: Record<WidgetKey, NestableWidget>,
-) =>
-	new t.Type<SharedSliceContentEntry, SharedSliceContentEntry, unknown>(
-		"SharedSliceContentEntry",
-		(u): u is SharedSliceContentEntry =>
-			t.tuple([WidgetKey, t.unknown]).is(u) && ImportNestable.is(u[1]),
-		(u, c) => {
-			return pipe(
-				t.tuple([WidgetKey, t.unknown]).validate(u, c),
-				E.chain(([key, content]) => {
-					const model: NestableWidget | undefined = sliceFieldModels[key]
-					if (!model) {
-						return t.failure(
-							[key, content],
-							[...c, { key, actual: content, type: t.unknown }],
-							SharedSliceContentErrors.UnknownField(
-								sliceName,
-								sliceContentField,
-								key,
-							),
-						)
-					}
-					const { codec, result } = ImportNestable.decode(model)(content)
-
-					return pipe(
-						result,
-						E.map<ImportNestable, SharedSliceContentEntry>((decodedContent) => [
-							key,
-							decodedContent,
-						]),
-						E.mapLeft(
-							(errors): t.Errors =>
-								errors.map((error) => {
-									const context = [
-										...c,
-										{ 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 }
-
-									return updatedError
-								}),
-						),
-					)
-				}),
-			)
-		},
-		t.identity,
-	)