@prismicio/types-internal 2.2.0-alpha.9 → 2.2.0-traverse.alpha-0

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceType.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 { SharedSlice as SharedSliceCustomType } from "../../../../../../customtypes"
+import { NonEmptyString } from "../../../../../../validators"
+import { findSlice } from "../utils"
+
+export type SharedSliceType = {
+	slice_type: string
+	data: SharedSliceCustomType
+}
+
+/**
+ * slice_type - the validated slice_type
+ * slice - SharedSlice custom type data matching the slice_type. We return it alongside the validated slice_type, because it is needed to decode the 'variation' field in the SharedSlice (see SharedSliceVariation.ts)
+ */
+const SharedSliceTypeShape = t.type({
+	slice_type: NonEmptyString,
+	slice: SharedSliceCustomType,
+})
+
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+export const SharedSliceType = (slices: SharedSliceCustomType[]) =>
+	new t.Type<SharedSliceType, string, unknown>(
+		"slice_type",
+		(u): u is SharedSliceType => SharedSliceTypeShape.is(u),
+		(u, c) =>
+			pipe(
+				NonEmptyString.validate(u, c),
+				E.chain((slice_type) =>
+					pipe(
+						findSlice(slices)(slice_type),
+						E.fold(
+							(err) => t.failure(u, c, err),
+							(data) => t.success({ slice_type, data }),
+						),
+					),
+				),
+			),
+		({ slice_type }) => slice_type,
+	)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceVariation.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 { SharedSlice, Variation } from "../../../../../../customtypes"
+import { NonEmptyString } from "../../../../../../validators"
+import { findSliceVariation } from "../utils"
+
+export type SharedSliceVariation = {
+	variation: string
+	data: Variation
+}
+
+/**
+ * variation - the validated variation of the slice
+ * data - Variation data matching the variation. We return it alongside the validated variation, because it is needed to decode the 'primary' and 'items' fields in the SharedSlice.
+ */
+const SharedSliceVariationShape = t.type({
+	variation: NonEmptyString,
+	data: Variation,
+})
+
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+export const SharedSliceVariation = (slice: SharedSlice) =>
+	new t.Type<SharedSliceVariation, string, unknown>(
+		"variation",
+		(u): u is SharedSliceVariation => SharedSliceVariationShape.is(u),
+		(u, c) =>
+			pipe(
+				NonEmptyString.validate(u, c),
+				E.chain((variation) =>
+					pipe(
+						findSliceVariation(slice)(variation),
+						E.fold(
+							(err) => t.failure(u, c, err),
+							(data) => t.success({ variation, data }),
+						),
+					),
+				),
+			),
+		({ variation }) => variation,
+	)

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

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

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

@@ -0,0 +1,3 @@
+export * from "./errors"
+export * from "./fields"
+export * from "./SharedSlice"

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

@@ -0,0 +1,21 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes"
+import type { Variation } from "../../../../../customtypes"
+import { SharedSliceErrors } from "./errors"
+
+export const findSlice =
+	(slices: SharedSliceCustomType[]) => (sliceId: string) =>
+		pipe(
+			slices.find((slice) => slice.id === sliceId),
+			E.fromNullable(SharedSliceErrors.SliceTypeNotFound(sliceId)),
+		)
+
+export const findSliceVariation =
+	(slice: SharedSliceCustomType) =>
+	(variation: string): E.Either<string, Variation> =>
+		pipe(
+			slice.variations.find((v) => v.id === variation),
+			E.fromNullable(SharedSliceErrors.VariationNotFound(variation, slice.id)),
+		)

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

@@ -0,0 +1 @@
+export * from "./ImportSlices"

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

@@ -0,0 +1,43 @@
+import * as A from "fp-ts/Array"
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+
+import {
+	SharedSlice as SharedSliceCustomType,
+	StaticSlices,
+} from "../../../../customtypes"
+import type { SharedSlice, SharedSliceId } from "./SharedSlice"
+
+// Extracts all supported slices from the static slices object
+// For now we only support the SharedSlice, if we want to support other slices in the future, we have to add them here
+export const extractSupportedSlices = (
+	staticSlices: StaticSlices,
+): SharedSliceCustomType[] =>
+	pipe(
+		Object.values(staticSlices.config?.choices ?? {}).map((slice) =>
+			pipe(SharedSliceCustomType.decode(slice), O.fromEither),
+		),
+		A.compact,
+	)
+
+export const findImportSharedSliceDuplicateIds = (
+	slices: SharedSlice[],
+): SharedSliceId[] => {
+	const duplicatesMap = slices.reduce((acc, { id }) => {
+		if (id) {
+			const currentNumOfDuplicates = acc[id] ?? 0
+			return {
+				...acc,
+				[id]: acc[id] === undefined ? 0 : currentNumOfDuplicates + 1,
+			}
+		}
+		return acc
+	}, {} as Record<SharedSliceId, number>)
+
+	return Object.entries(duplicatesMap).flatMap(([id, numOfDuplicates]) => {
+		if (numOfDuplicates > 0) {
+			return [id]
+		}
+		return []
+	})
+}

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

@@ -1,6 +1,6 @@
 import * as t from "io-ts"
 
-import { NullOrElse, String } from "../../../validators"
+import { String } from "../../../validators"
 import { ImportContent } from "./ImportContent"
 
 const regex = /^[a-z0-9-_.]+$/
@@ -23,5 +23,5 @@ const uidValue = String.pipe(
 	),
 )
 
-export const ImportUID = ImportContent("UID", NullOrElse(uidValue))
+export const ImportUID = ImportContent("UID", uidValue)
 export type ImportUID = t.TypeOf<typeof ImportUID>

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

@@ -1,14 +1,8 @@
-import * as Either from "fp-ts/lib/Either"
+import * as Either from "fp-ts/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
-import { withMessage } from "io-ts-types"
 
 import { EmptyObjectOrElse } from "../../../../validators"
-import {
-	NumberOrNull,
-	String,
-	StringOrNull,
-} from "../../../../validators/BasicTypes"
 import { ImportContent } from "../ImportContent"
 
 type URL = string
@@ -38,49 +32,23 @@ const EmbedUrl = new t.Type<URL, URL, unknown>(
 	t.identity,
 )
 
-const EmbedProto = t.exact(
-	t.intersection([
-		t.type({
-			embed_url: EmbedUrl,
-			type: String,
-		}),
-		t.partial({
-			version: withMessage(
-				t.union([t.string, t.number, t.null]),
-				() => "The value must be either string, number or null",
-			),
-			title: String,
-			author_name: StringOrNull,
-			author_url: StringOrNull,
-			provider_name: StringOrNull,
-			provider_url: StringOrNull,
-			cache_age: withMessage(
-				t.union([t.string, t.number, t.null]),
-				() => "The value must be either string, number or null",
-			),
-			thumbnail_url: StringOrNull,
-			thumbnail_width: NumberOrNull,
-			thumbnail_height: NumberOrNull,
-			html: StringOrNull,
-		}),
-	]),
-)
+const EmbedProto = t.type({
+	embed_url: EmbedUrl,
+})
 type EmbedProto = t.TypeOf<typeof EmbedProto>
 
-type Embed = EmbedProto & {
-	all: unknown
-}
-const embedValue = new t.Type<Embed>(
+type Embed = EmbedProto
+const Embed = new t.Type<Embed>(
 	"ImportEmbedValue",
-	(u: unknown): u is Embed => EmbedProto.is(u) && "all" in u,
+	(u: unknown): u is Embed => EmbedProto.is(u),
 	(u: unknown) => {
 		return pipe(
 			EmbedProto.decode(u),
-			Either.map((parsed) => ({ ...parsed, all: u })),
+			Either.map((parsed) => ({ embed_url: parsed.embed_url })),
 		)
 	},
 	t.identity,
 )
 
-export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(embedValue))
+export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(Embed))
 export type ImportEmbed = t.TypeOf<typeof ImportEmbed>

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

@@ -2,10 +2,10 @@ import type { TypeOf } from "io-ts"
 import * as t from "io-ts"
 
 import { EmptyObjectOrElse, NumberRange } from "../../../../validators"
-import { withFallbackMessage } from "../../../../validators/function"
+import { withCustomError } from "../../../../validators/function"
 import { ImportContent } from "../ImportContent"
 
-const GeooPoint = withFallbackMessage(
+const GeooPoint = withCustomError(
 	t.strict({
 		latitude: NumberRange(-90, 90, "latitude"),
 		longitude: NumberRange(-180, 180, "longitude"),

package/src/import/validators/fields/nestable/Image/Decoder.ts

@@ -0,0 +1,61 @@
+import type { TypeOf } from "io-ts"
+
+import type { Image } from "../../../../../customtypes"
+import type ImageConstraint from "../../../../../customtypes/widgets/shared/ImageConstraint"
+import type { ImageField } from "./model"
+import type { ImageFieldValidator, ThumbnailsValidator } from "./Validator"
+
+// This function merges user input with custom type constraints.
+// If `image` is missing, `mainImage` is used for the encoding
+// (case when user input lacks thumbnail definition)
+export const decodeImageField = (
+	image: TypeOf<typeof ImageFieldValidator> | undefined,
+	mainImage: TypeOf<typeof ImageFieldValidator>,
+	constraints?: ImageConstraint,
+): ImageField => {
+	const background = image?.edit?.background
+	const width =
+		constraints?.width ??
+		image?.dimensions?.width ??
+		mainImage.dimensions?.width
+	const height =
+		constraints?.height ??
+		image?.dimensions?.height ??
+		mainImage.dimensions?.height
+	const alt = image?.alt
+	const copyright = image?.copyright
+
+	return {
+		id: image?.id ?? mainImage?.id,
+		edit: {
+			x: image?.edit?.x ?? 0,
+			y: image?.edit?.y ?? 0,
+			zoom: image?.edit?.zoom ?? 1,
+			...(background !== undefined ? { background } : {}),
+		},
+		dimensions: {
+			...(width !== undefined ? { width } : {}),
+			...(height !== undefined ? { height } : {}),
+		},
+		...(alt !== undefined ? { alt } : {}),
+		...(copyright !== undefined ? { copyright } : {}),
+	}
+}
+// Merges provided thumbnails with custom type constraints.
+// If any thumbnail is missing, it is created using the origin image (`mainImage`)
+export const decodeThumbnails = (
+	mainImage: TypeOf<typeof ImageFieldValidator>,
+	thumbnails: TypeOf<typeof ThumbnailsValidator>,
+	field?: Image,
+) =>
+	field?.config?.thumbnails?.reduce(
+		(acc, thumbnail) => ({
+			...acc,
+			[thumbnail.name]: decodeImageField(
+				thumbnails[thumbnail.name],
+				mainImage,
+				thumbnail,
+			),
+		}),
+		{},
+	) ?? {}

package/src/import/validators/fields/nestable/Image/Validator.ts

@@ -0,0 +1,38 @@
+import * as t from "io-ts"
+
+import {
+	Number,
+	String,
+	StringOrNull,
+} from "../../../../../validators/BasicTypes"
+import { withCustomError } from "../../../../../validators/function"
+
+export const ImageFieldValidator = withCustomError(
+	t.intersection([
+		t.type({
+			id: String,
+		}),
+		t.partial({
+			dimensions: withCustomError(
+				t.partial({
+					width: Number,
+					height: Number,
+				}),
+				() => "The value must be an object",
+			),
+			edit: withCustomError(
+				t.partial({
+					x: Number,
+					y: Number,
+					zoom: Number,
+					background: String,
+				}),
+				() => "The value must be an object",
+			),
+			copyright: StringOrNull,
+			alt: StringOrNull,
+		}),
+	]),
+	() => "The value must be an object",
+)
+export const ThumbnailsValidator = t.record(t.string, ImageFieldValidator)

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

@@ -0,0 +1,75 @@
+import { chain, map } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import type { Validation } from "io-ts"
+import * as t from "io-ts"
+
+import type { Image as ImageDefinition } from "../../../../../customtypes"
+import { DefaultOrElse, EmptyObject } from "../../../../../validators"
+import { withCustomError } from "../../../../../validators/function"
+import { ImportContent } from "../../ImportContent"
+import { decodeImageField, decodeThumbnails } from "./Decoder"
+import type { ImageFieldWithThumbnails } from "./model"
+import { ImageFieldValidator, ThumbnailsValidator } from "./Validator"
+
+const defaultImage = (field?: ImageDefinition) => {
+	// If there is not thumbnails we expect an empty object
+	if (!field?.config?.thumbnails || !field.config.thumbnails.length)
+		return EmptyObject
+
+	// If there are thumbnails, we expect an object with thumbnails as empty objects
+	return withCustomError(
+		t.strict(
+			field.config.thumbnails.reduce(
+				(acc, thumbnail) => ({
+					...acc,
+					[thumbnail.name]: EmptyObject,
+				}),
+				{},
+			),
+		),
+		() => "The value must be an object",
+	)
+}
+
+const ImageField = (field?: ImageDefinition) =>
+	new t.Type<ImageFieldWithThumbnails>(
+		"ImageField",
+		(u: unknown): u is ImageFieldWithThumbnails =>
+			ImageFieldValidator.is(u) &&
+			"thumbnails" in u &&
+			ThumbnailsValidator.is(u["thumbnails"]),
+		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
+			return pipe(
+				ImageFieldValidator.validate(u, ctx),
+				chain((mainImage) => {
+					const { id, dimensions, edit, copyright, alt, ...maybeThumbnails } =
+						mainImage
+					return pipe(
+						ThumbnailsValidator.validate(maybeThumbnails, ctx),
+						map((thumbnails) => ({
+							...decodeImageField(
+								mainImage,
+								mainImage,
+								field?.config?.constraint,
+							),
+							thumbnails: decodeThumbnails(mainImage, thumbnails, field),
+						})),
+					)
+				}),
+			)
+		},
+		t.identity,
+	)
+
+const ImageCodec = (field?: ImageDefinition) =>
+	withCustomError(
+		DefaultOrElse<Record<never, never>, ImageFieldWithThumbnails>(
+			defaultImage(field),
+		)(ImageField(field)),
+		() => "An image field must be an object",
+	)
+
+export const ImportImage = (field?: ImageDefinition) =>
+	ImportContent("Image", ImageCodec(field))
+export type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>
+export * from "./model"

package/src/import/validators/fields/nestable/Image/model.ts

@@ -0,0 +1,18 @@
+export type ImageField = {
+	id: string
+	edit: {
+		x: number
+		y: number
+		zoom: number
+		background?: string
+	}
+	dimensions: {
+		width?: number
+		height?: number
+	}
+	copyright?: string | null
+	alt?: string | null
+}
+export type ImageFieldWithThumbnails = ImageField & {
+	thumbnails: Record<string, ImageField>
+}

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

@@ -1,13 +1,13 @@
 import type { OutputOf, TypeOf } from "io-ts"
 import * as t from "io-ts"
-import { withMessage } from "io-ts-types"
 
 import { DocumentId } from "../../../../utils/DocumentId"
 import { DefaultOrElse, String } from "../../../../validators"
+import { withCustomError } from "../../../../validators/function"
 import { ImportContent } from "../ImportContent"
 
 const LinkTypeValidator = t.type({
-	link_type: withMessage(
+	link_type: withCustomError(
 		t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]),
 		() => "The value must be `Web`, `Document` or `Media`",
 	),

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

@@ -4,6 +4,7 @@ export * from "./Date"
 export * from "./Embed"
 export * from "./GeoPoint"
 export * from "./Image"
+export * from "./Image/index"
 export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"

package/src/utils/DocumentId.ts

@@ -1,9 +1,8 @@
-import { withMessage } from "io-ts-types"
+import * as t from "io-ts"
 
-import { String } from "../validators"
-import { refineType } from "../validators/function"
+import { refineType, withCustomError } from "../validators/function"
 
-export const DocumentId = withMessage(
-	refineType(String, "DocumentId", (s) => s.length === 16),
+export const DocumentId = withCustomError(
+	refineType(t.string, "DocumentId", (s) => s.length === 16),
 	() => "DocumentId must be a 16 character string",
 )

package/src/utils/io-ts.ts

@@ -0,0 +1,29 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as RA from "fp-ts/ReadonlyArray"
+import type { Semigroup } from "fp-ts/Semigroup"
+import type { Errors, Validation } from "io-ts"
+
+/*
+ * Semigroup simply defines how to concatenate two values of the same type.
+ * In this instance, Errors from io-ts are arrays already, so we just need to concatenate them.
+ */
+const validationErrorsSemigroup: Semigroup<Errors> = {
+	concat: (a: Errors, b: Errors) => [...a, ...b],
+}
+
+/*
+ * This is a helper function to combine multiple io-ts validations into one.
+ *  t.array(...) works in the same way - it collects all the errors when decoding an array of values.
+ * 	However, it requires you to pass in a single io-ts validator as a parameter, which is not always convenient.
+ * 	Sometimes we have arrays of validation results received from function calls that don't have a validator instance.
+ */
+export const combineValidationResults = <T>(
+	validationResults: readonly Validation<T>[],
+): Validation<readonly T[]> =>
+	pipe(
+		validationResults,
+		RA.traverse(E.getApplicativeValidation(validationErrorsSemigroup))(
+			(validation) => validation,
+		),
+	)

package/src/validators/BasicTypes.ts

@@ -1,19 +1,26 @@
 import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
-import { withMessage } from "io-ts-types"
 
-export const String = withMessage(t.string, () => "The value must be a string")
-export const StringOrNull = withMessage(
+import { withCustomError } from "./function"
+
+export const String = withCustomError(
+	t.string,
+	() => "The value must be a string",
+)
+export const StringOrNull = withCustomError(
 	t.union([t.string, t.null]),
 	() => "The value must be a string or null",
 )
-export const Number = withMessage(t.number, () => "The value must be a number")
-export const NumberOrNull = withMessage(
+export const Number = withCustomError(
+	t.number,
+	() => "The value must be a number",
+)
+export const NumberOrNull = withCustomError(
 	t.union([t.number, t.null]),
 	() => "The value must be a number or null",
 )
-export const Boolean = withMessage(
+export const Boolean = withCustomError(
 	t.boolean,
 	() => "The value must be a boolean",
 )
@@ -46,8 +53,3 @@ export const EmptyArray = new t.Type<never[], never[], unknown>(
 	},
 	() => [],
 )
-
-export const AnyObject = withMessage(
-	t.record(t.string, t.unknown),
-	() => "The value must be an object",
-)

package/src/validators/DefaultOrElse.ts

@@ -6,7 +6,7 @@ import { EmptyArray, EmptyObject } from "./BasicTypes"
 export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
 	return (codec: t.Type<A, O>) =>
 		new t.Type<A | null, O | undefined>(
-			"NullOrT",
+			"DefaultOrElse",
 			(u: unknown): u is A | null => null === u || codec.is(u),
 			(u: unknown) => {
 				if (isRight(inputValidator.decode(u))) return t.success(null)

package/src/validators/NonEmptyString.ts

@@ -1,9 +1,8 @@
 import * as t from "io-ts"
 
-import { refineType } from "./function"
+import { refineType, withCustomError } from "./function"
 
-export default refineType(
-	t.string,
-	"nonEmptyString",
-	(s) => s.trim().length > 0,
+export default withCustomError(
+	refineType(t.string, "nonEmptyString", (s) => s.trim().length > 0),
+	() => "The value must be a non-empty string",
 )

package/src/validators/function.ts

@@ -78,19 +78,19 @@ export function addType<A, O extends object, I, T extends string>(
  *
  * @example
  * expect(
- * 		withFallbackMessage(
- * 			t.type({age: withMessage(t.number, () => 'Invalid child')}),
+ * 		withCustomError(
+ * 			t.type({age: withCustomError(t.number, () => 'Invalid child')}),
  * 			() => "Invalid parent"
  * 		)
  * ).toSubsetEqualLeft([{message: "Invalid child"}])
  * expect(
- * 		withFallbackMessage(
+ * 		withCustomError(
  * 			t.type({age: t.number}),
  * 			() => "Invalid parent"
  * 		)
  * ).toSubsetEqualLeft([{message: "Invalid parent"}])
  */
-export function withFallbackMessage<C extends t.Any>(
+export function withCustomError<C extends t.Any>(
 	codec: C,
 	message: (i: t.InputOf<C>, c: t.Context) => string,
 ): C {