@prismicio/types-internal 2.2.0-alpha.24 → 2.2.0-alpha.26

package/lib/import/validators/fields/nestable/Nestable.d.ts

@@ -62,7 +62,7 @@ export declare const ImportNestable: {
         } | undefined, unknown> | import("io-ts").Type<{
             type: "StructuredText";
             value: import("./ImportRichText").ImportBlock[] | null;
-        }, unknown[] | undefined, unknown> | import("io-ts").Type<{
+        }, import("./ImportRichText").ImportBlock[] | undefined, unknown> | import("io-ts").Type<{
             type: "Number";
             value: number | null;
         }, number | undefined, unknown> | import("io-ts").Type<{
@@ -129,4 +129,64 @@ export declare const ImportNestable: {
             value: boolean | null;
         }>;
     };
+    getCodec: (field: NestableWidget) => import("io-ts").Type<{
+        type: "Boolean";
+        value: boolean | null;
+    }, boolean | undefined, unknown> | import("io-ts").Type<{
+        type: "Color";
+        value: `#${string}` | null;
+    }, string | undefined, unknown> | import("io-ts").Type<{
+        type: "Date";
+        value: Date | null;
+    }, Date | undefined, unknown> | import("io-ts").Type<{
+        type: "Embed";
+        value: {
+            embed_url: string;
+        } | null;
+    }, {
+        embed_url: string;
+    } | undefined, unknown> | import("io-ts").Type<{
+        type: "GeoPoint";
+        value: {
+            latitude: number;
+            longitude: number;
+        } | null;
+    }, {
+        latitude: number;
+        longitude: number;
+    } | undefined, unknown> | import("io-ts").Type<{
+        type: "Image";
+        value: import("./Image").ImageFieldWithThumbnails | null;
+    }, import("./Image").ImageFieldWithThumbnails | undefined, unknown> | import("io-ts").Type<{
+        type: "Link";
+        value: ({
+            link_type: "Web";
+            url: string;
+        } & {
+            target?: string;
+        }) | {
+            link_type: "Document";
+            id: string;
+        } | {
+            link_type: "Media";
+            id: string;
+        } | null;
+    }, {
+        link_type: "Document" | "Web" | "Media";
+    } | undefined, unknown> | import("io-ts").Type<{
+        type: "StructuredText";
+        value: import("./ImportRichText").ImportBlock[] | null;
+    }, import("./ImportRichText").ImportBlock[] | undefined, unknown> | import("io-ts").Type<{
+        type: "Number";
+        value: number | null;
+    }, number | undefined, unknown> | import("io-ts").Type<{
+        type: "Select";
+        value: string | null;
+    }, string | undefined, unknown> | import("io-ts").Type<{
+        type: "Text";
+        value: string | null;
+    }, string | undefined, unknown> | import("io-ts").Type<{
+        type: "Timestamp";
+        value: Date | null;
+    }, Date | undefined, unknown>;
 };

package/lib/import/validators/fields/nestable/Nestable.js

@@ -13,6 +13,36 @@ const Number_1 = require("./Number");
 const Select_1 = require("./Select");
 const Text_1 = require("./Text");
 const Timestamp_1 = require("./Timestamp");
+const getCodecOrThrow = (field) => {
+    switch (field.type) {
+        case "Boolean":
+            return Boolean_1.ImportBoolean;
+        case "Color":
+            return Color_1.ImportColor;
+        case "Number":
+            return (0, Number_1.ImportNumber)(field);
+        case "Select":
+            return (0, Select_1.ImportSelect)(field);
+        case "Text":
+            return Text_1.ImportText;
+        case "Date":
+            return Date_1.ImportDate;
+        case "Timestamp":
+            return Timestamp_1.ImportTimestamp;
+        case "Embed":
+            return Embed_1.ImportEmbed;
+        case "Link":
+            return Link_1.ImportLink;
+        case "Image":
+            return (0, Image_1.ImportImage)(field);
+        case "GeoPoint":
+            return GeoPoint_1.ImportGeoPoint;
+        case "StructuredText":
+            return (0, ImportRichText_1.ImportRichText)(field);
+        default:
+            throw new Error(`Unsupported type of nestable field ${field.type}`);
+    }
+};
 exports.ImportNestable = {
     is(u) {
         return (Boolean_1.ImportBoolean.is(u) ||
@@ -30,40 +60,12 @@ exports.ImportNestable = {
     },
     decode: (field) => {
         return (content) => {
-            const codec = (() => {
-                switch (field.type) {
-                    case "Boolean":
-                        return Boolean_1.ImportBoolean;
-                    case "Color":
-                        return Color_1.ImportColor;
-                    case "Number":
-                        return (0, Number_1.ImportNumber)(field);
-                    case "Select":
-                        return (0, Select_1.ImportSelect)(field);
-                    case "Text":
-                        return Text_1.ImportText;
-                    case "Date":
-                        return Date_1.ImportDate;
-                    case "Timestamp":
-                        return Timestamp_1.ImportTimestamp;
-                    case "Embed":
-                        return Embed_1.ImportEmbed;
-                    case "Link":
-                        return Link_1.ImportLink;
-                    case "Image":
-                        return (0, Image_1.ImportImage)(field);
-                    case "GeoPoint":
-                        return GeoPoint_1.ImportGeoPoint;
-                    case "StructuredText":
-                        return (0, ImportRichText_1.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/lib/validators/DefaultOrElse.js

@@ -6,7 +6,7 @@ const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const BasicTypes_1 = require("./BasicTypes");
 const DefaultOrElse = (inputValidator) => {
-    return (codec) => new t.Type("DefaultOrElse", (u) => null === u || codec.is(u), (u, c) => {
+    return (codec) => new t.Type(`DefaultOrElse<${inputValidator.name}, ${codec.name}>`, (u) => null === u || codec.is(u), (u, c) => {
         if ((0, Either_1.isRight)(inputValidator.validate(u, c)))
             return t.success(null);
         return codec.validate(u, c);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.24",
+	"version": "2.2.0-alpha.26",
 	"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/ImportContent.ts

@@ -10,7 +10,7 @@ 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"])

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/ImportSlices.ts

@@ -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",
 		EmptyArrayOrElse(
-			new t.Type<SharedSlice[]>(
-				"ImportSlices",
+			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/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"