@prismicio/types-internal 2.2.0-alpha.2 → 2.2.0-alpha.21

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

@@ -0,0 +1 @@
+export type SharedSliceContentField = "primary" | "items"

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

@@ -0,0 +1,65 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { UUID } from "../../../../../../common/UUID"
+import { NonEmptyString } from "../../../../../../validators"
+
+export type SharedSliceId = `${string}$${UUID}`
+
+const baseErrorText =
+	"Slice id must be a non empty string matching the following pattern 'slice_type$uuid'"
+
+export const SharedSliceIdValidationError = {
+	Base: baseErrorText,
+	IncorrectUUID: (uuid: string | undefined) =>
+		`Incorrect UUID: '${uuid}' - ${baseErrorText}`,
+	IncorrectSliceType: (sliceType: string | undefined) =>
+		`Incorrect slice_type: '${sliceType}' - ${baseErrorText}`,
+} as const
+
+export const SharedSliceId = new t.Type<SharedSliceId, string, unknown>(
+	"SharedSliceId",
+	(u): u is SharedSliceId => {
+		if (typeof u !== "string") {
+			return false
+		}
+		const [sliceName, uuid] = u.split("$")
+		return NonEmptyString.is(sliceName) && UUID.is(uuid)
+	},
+	(u, c) =>
+		pipe(
+			NonEmptyString.validate(u, c),
+			E.mapLeft((errors) =>
+				errors.map(
+					(error): t.ValidationError => ({
+						...error,
+						message: SharedSliceIdValidationError.Base,
+					}),
+				),
+			),
+			E.chain((sliceId) => {
+				const [sliceName, uuid] = sliceId.split("$")
+				return pipe(
+					t.tuple([NonEmptyString, UUID]).validate([sliceName, uuid], c),
+					E.mapLeft((errors) =>
+						errors.map((error): t.ValidationError => {
+							const tupleErrorContext = error.context[error.context.length - 1]
+							return {
+								...error,
+								context: [
+									...error.context.slice(0, -1), // We don't want the tuple decoder error context
+								],
+								message:
+									tupleErrorContext?.key === "0"
+										? SharedSliceIdValidationError.IncorrectSliceType(sliceName)
+										: SharedSliceIdValidationError.IncorrectUUID(uuid),
+							}
+						}),
+					),
+				)
+			}),
+			E.map(([sliceName, uuid]) => `${sliceName}$${uuid}`),
+		),
+	(sliceId) => sliceId,
+)

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.strict({
+	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.strict({
+	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,6 @@
-import * as Either from "fp-ts/lib/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 +30,12 @@ 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,
-		}),
-	]),
-)
-type EmbedProto = t.TypeOf<typeof EmbedProto>
+export const ImportEmbedValue = t.strict({
+	embed_url: EmbedUrl,
+})
 
-type Embed = EmbedProto & {
-	all: unknown
-}
-const embedValue = new t.Type<Embed>(
-	"ImportEmbedValue",
-	(u: unknown): u is Embed => EmbedProto.is(u) && "all" in u,
-	(u: unknown) => {
-		return pipe(
-			EmbedProto.decode(u),
-			Either.map((parsed) => ({ ...parsed, all: u })),
-		)
-	},
-	t.identity,
+export const ImportEmbed = ImportContent(
+	"Embed",
+	EmptyObjectOrElse(ImportEmbedValue),
 )
-
-export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(embedValue))
 export type ImportEmbed = t.TypeOf<typeof ImportEmbed>

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

@@ -0,0 +1,21 @@
+import type { TypeOf } from "io-ts"
+import * as t from "io-ts"
+
+import { EmptyObjectOrElse, NumberRange } from "../../../../validators"
+import { withCustomError } from "../../../../validators/function"
+import { ImportContent } from "../ImportContent"
+
+const GeoPoint = withCustomError(
+	t.strict({
+		latitude: NumberRange(-90, 90, "latitude"),
+		longitude: NumberRange(-180, 180, "longitude"),
+	}),
+	() =>
+		"GeoPoint must be an object with the properties `latitude` and `longitude` between the given ranges",
+)
+
+export const ImportGeoPoint = ImportContent(
+	"GeoPoint",
+	EmptyObjectOrElse(GeoPoint),
+)
+export type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>

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

@@ -0,0 +1,25 @@
+import * as t from "io-ts"
+
+import type { Image as ImageDefinition } from "../../../../../customtypes"
+import { EmptyObject } from "../../../../../validators"
+import { withCustomError } from "../../../../../validators/function"
+
+export const defaultImportImage = (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",
+	)
+}

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

@@ -0,0 +1,73 @@
+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 } from "../../../../../validators"
+import { withCustomError } from "../../../../../validators/function"
+import { ImportContent } from "../../ImportContent"
+import { defaultImportImage } from "./default"
+import {
+	mergeImageViewWithCtConstraints,
+	mergeThumbnailsWithCtConstraints,
+} from "./merge"
+import type { ImageFieldWithThumbnails } from "./model"
+import { ImportImageView, ImportThumbnails } from "./validators"
+
+/* For code clarity, the output of this validator will be simplified
+ *
+ *  Input -> type ImageAPIV2 = ImportImageView & ImportThumbnails
+ *  Output -> type ImageWithThumbnails 👇
+ */
+
+export const ImageFieldCodec = (field?: ImageDefinition) =>
+	new t.Type<ImageFieldWithThumbnails>(
+		"ImageField",
+		(u: unknown): u is ImageFieldWithThumbnails =>
+			ImportImageView.is(u) &&
+			"thumbnails" in u &&
+			ImportThumbnails.is(u["thumbnails"]),
+		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
+			return pipe(
+				// Validating the higher level image
+				ImportImageView.validate(u, ctx),
+				chain((imageApiV2) => {
+					const { id, dimensions, edit, copyright, alt, ...thumbnails } =
+						imageApiV2
+
+					return pipe(
+						// Validating the thumbnails
+						ImportThumbnails.validate(thumbnails, ctx),
+						map((thumbnails) => ({
+							...mergeImageViewWithCtConstraints(
+								imageApiV2,
+								imageApiV2,
+								field?.config?.constraint,
+							),
+							thumbnails: mergeThumbnailsWithCtConstraints(
+								thumbnails,
+								imageApiV2,
+								field,
+							),
+						})),
+					)
+				}),
+			)
+		},
+		t.identity,
+	)
+
+const ImageCodec = (field?: ImageDefinition) =>
+	withCustomError(
+		DefaultOrElse<Record<never, never>, ImageFieldWithThumbnails>(
+			defaultImportImage(field),
+		)(ImageFieldCodec(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/merge.ts

@@ -0,0 +1,64 @@
+import type { Image } from "../../../../../customtypes"
+import type ImageConstraint from "../../../../../customtypes/widgets/shared/ImageConstraint"
+import type { ImageField } from "./model"
+import type { ImportImageView, ImportThumbnails } from "./validators"
+
+/* This function merges user input with custom type constraints.
+ *  If a thumbnails' data are missing (`image`) then the default is used (`defaultImage`)
+ */
+export const mergeImageViewWithCtConstraints = (
+	image: ImportImageView | undefined,
+	defaultImage: ImportImageView,
+	constraints: ImageConstraint | undefined,
+): ImageField => {
+	const background = image?.edit?.background
+	const width =
+		constraints?.width ??
+		image?.dimensions?.width ??
+		defaultImage?.dimensions?.width
+	const height =
+		constraints?.height ??
+		image?.dimensions?.height ??
+		defaultImage?.dimensions?.height
+	const alt = image?.alt
+	const copyright = image?.copyright
+
+	return {
+		id: image?.id ?? defaultImage?.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 } : {}),
+	}
+}
+
+/* This function handles each thumbnail defined in the custom type.
+ *
+ *  For each of them it merges the user input with custom type constraints.
+ *
+ *  If a thumbnail is missing, the data from the default image is used.
+ */
+export const mergeThumbnailsWithCtConstraints = (
+	thumbnails: ImportThumbnails,
+	defaultImage: ImportImageView,
+	field?: Image,
+) =>
+	field?.config?.thumbnails?.reduce(
+		(acc, thumbnail) => ({
+			...acc,
+			[thumbnail.name]: mergeImageViewWithCtConstraints(
+				thumbnails[thumbnail.name],
+				defaultImage,
+				thumbnail,
+			),
+		}),
+		{},
+	) ?? {}

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/Image/validators.ts

@@ -0,0 +1,45 @@
+import * as t from "io-ts"
+
+import {
+	Number,
+	String,
+	StringOrNull,
+} from "../../../../../validators/BasicTypes"
+import { withCustomError } from "../../../../../validators/function"
+
+export const ImportImageView = withCustomError(
+	t.intersection([
+		t.type({
+			// Image Id
+			id: String,
+		}),
+		t.partial({
+			// Dimensions here will be used if they are not defined in the custom type
+			dimensions: withCustomError(
+				t.partial({
+					width: Number,
+					height: Number,
+				}),
+				() => "The value must be an object",
+			),
+			// Crop information
+			edit: withCustomError(
+				t.partial({
+					x: Number,
+					y: Number,
+					zoom: Number,
+					background: String,
+				}),
+				() => "The value must be an object",
+			),
+			// Copyrights and alt are set in the Asset by default but they can be overrided
+			copyright: StringOrNull,
+			alt: StringOrNull,
+		}),
+	]),
+	() => "The value must be an object",
+)
+export type ImportImageView = t.TypeOf<typeof ImportImageView>
+
+export const ImportThumbnails = t.record(t.string, ImportImageView)
+export type ImportThumbnails = t.TypeOf<typeof ImportThumbnails>

package/src/import/validators/fields/nestable/ImportRichText/ImportBlock.ts

@@ -0,0 +1,39 @@
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../validators/function"
+import {
+	ImportBlockType,
+	ImportEmbedBlock,
+	ImportImageBlock,
+	ImportTextBlock,
+} from "./blocks"
+
+export type ImportBlock = ImportTextBlock | ImportImageBlock | ImportEmbedBlock
+
+export const ImportBlock = (allowedBlockTypes: string[]) =>
+	withCustomError(
+		t
+			.type({
+				type: ImportBlockType(allowedBlockTypes),
+			})
+			.pipe(
+				new t.Type<ImportBlock, ImportBlock, { type: ImportBlockType }>(
+					"ImportBlock",
+					(u): u is ImportBlock =>
+						t
+							.union([ImportTextBlock, ImportImageBlock, ImportEmbedBlock])
+							.is(u),
+					(u, c) => {
+						if (u.type === "image") {
+							return ImportImageBlock.validate(u, c)
+						} else if (u.type === "embed") {
+							return ImportEmbedBlock.validate(u, c)
+						} else {
+							return ImportTextBlock.validate(u, c)
+						}
+					},
+					t.identity,
+				),
+			),
+		() => "Rich text block must be an object",
+	)

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

@@ -0,0 +1,41 @@
+import * as t from "io-ts"
+
+import type { RichText as RichTextCustomType } from "../../../../../customtypes"
+import { EmptyArrayOrElse } from "../../../../../validators"
+import { withCustomError } from "../../../../../validators/function"
+import { ImportContent } from "../../ImportContent"
+import { ImportBlock } from "./ImportBlock"
+
+export const ImportRichText = (customType?: RichTextCustomType) =>
+	ImportContent(
+		"StructuredText",
+		EmptyArrayOrElse(
+			withCustomError(
+				t.array(t.unknown).pipe(
+					new t.Type<ImportBlock[], ImportBlock[], unknown[]>(
+						"RichTextField",
+						(u): u is ImportBlock[] => t.array(ImportBlock([])).is(u),
+						(u, c) => {
+							const single = customType?.config?.single?.split(",")
+							const multi = customType?.config?.multi?.split(",")
+
+							if (multi) {
+								return t.array(ImportBlock(multi)).validate(u, c)
+							} else if (single) {
+								return u.length > 1
+									? t.failure(u, c, "This field only allows one block")
+									: t.array(ImportBlock(single)).validate(u, c)
+							} else {
+								throw new Error(
+									"Rich text config must have either a 'single' or 'multi' field defined",
+								)
+							}
+						},
+						t.identity,
+					),
+				),
+				() => "Rich text field must be an array",
+			),
+		),
+	)
+export type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>