@prismicio/types-internal 2.2.0-alpha.1 → 2.2.0-alpha.10

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

@@ -0,0 +1,54 @@
+import * as Either from "fp-ts/Either"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { EmptyObjectOrElse } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
+
+type URL = string
+
+function isValidHttpUrl(param: unknown): param is URL {
+	try {
+		if (typeof param !== "string") {
+			return false
+		}
+		const url = new URL(param)
+		return ["http:", "https:"].includes(url.protocol)
+	} catch (err) {
+		return false
+	}
+}
+
+const EmbedUrl = new t.Type<URL, URL, unknown>(
+	"EmbedUrl",
+	(u: unknown): u is URL => isValidHttpUrl(u),
+	(u: unknown, c: t.Context) => {
+		if (isValidHttpUrl(u)) {
+			return t.success(u)
+		} else {
+			return t.failure(u, c, "The value must be a valid http/https url")
+		}
+	},
+	t.identity,
+)
+
+const EmbedProto = t.type({
+	embed_url: EmbedUrl,
+})
+type EmbedProto = t.TypeOf<typeof EmbedProto>
+
+type Embed = EmbedProto
+const Embed = new t.Type<Embed>(
+	"ImportEmbedValue",
+	(u: unknown): u is Embed => EmbedProto.is(u),
+	(u: unknown) => {
+		return pipe(
+			EmbedProto.decode(u),
+			Either.map((parsed) => ({ embed_url: parsed.embed_url })),
+		)
+	},
+	t.identity,
+)
+
+export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(Embed))
+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 { withFallbackMessage } from "../../../../validators/function"
+import { ImportContent } from "../ImportContent"
+
+const GeooPoint = withFallbackMessage(
+	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(GeooPoint),
+)
+export type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>

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 credit = image?.credit
+
+	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 } : {}),
+		...(credit !== undefined ? { credit } : {}),
+	}
+}
+// 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,35 @@
+import * as t from "io-ts"
+
+import {
+	AnyObject,
+	Number,
+	String,
+	StringOrNull,
+} from "../../../../../validators/BasicTypes"
+
+export const ImageFieldValidator = AnyObject.pipe(
+	t.intersection([
+		t.type({
+			id: String,
+		}),
+		t.partial({
+			dimensions: AnyObject.pipe(
+				t.partial({
+					width: Number,
+					height: Number,
+				}),
+			),
+			edit: AnyObject.pipe(
+				t.partial({
+					x: Number,
+					y: Number,
+					zoom: Number,
+					background: String,
+				}),
+			),
+			credit: StringOrNull,
+			alt: StringOrNull,
+		}),
+	]),
+)
+export const ThumbnailsValidator = t.record(t.string, ImageFieldValidator)

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

@@ -0,0 +1,45 @@
+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 { NullOrElse } from "../../../../../validators"
+import { ImportContent } from "../../ImportContent"
+import { decodeImageField, decodeThumbnails } from "./Decoder"
+import type { ImageFieldWithThumbnails } from "./model"
+import { ImageFieldValidator, ThumbnailsValidator } from "./Validator"
+
+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, credit, alt, ...maybeThumbnails } =
+						mainImage
+					return pipe(
+						ThumbnailsValidator.validate(maybeThumbnails, ctx),
+						map((thumbnails) => ({
+							...decodeImageField(
+								mainImage,
+								mainImage,
+								field?.config?.constraint,
+							),
+							thumbnails: decodeThumbnails(mainImage, thumbnails, field),
+						})),
+					)
+				}),
+			)
+		},
+		t.identity,
+	)
+export const ImportImage = (field?: ImageDefinition) =>
+	ImportContent("Image", NullOrElse(ImageField(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
+	}
+	credit?: string | null
+	alt?: string | null
+}
+export type ImageFieldWithThumbnails = ImageField & {
+	thumbnails: Record<string, ImageField>
+}

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

@@ -0,0 +1,54 @@
+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 { ImportContent } from "../ImportContent"
+
+const LinkTypeValidator = t.type({
+	link_type: withMessage(
+		t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]),
+		() => "The value must be `Web`, `Document` or `Media`",
+	),
+})
+
+const WebLink = t.intersection([
+	t.type({
+		link_type: t.literal("Web"),
+		url: String,
+	}),
+	t.partial({
+		target: String,
+	}),
+])
+export type WebLink = t.TypeOf<typeof WebLink>
+
+const DocumentLink = t.type({
+	link_type: t.literal("Document"),
+	id: DocumentId,
+})
+export type DocumentLink = t.TypeOf<typeof DocumentLink>
+
+const MediaLink = t.type({
+	link_type: t.literal("Media"),
+	id: String,
+})
+export type MediaLink = t.TypeOf<typeof MediaLink>
+
+const Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]))
+
+// This is the default value for the link
+const AnyLink = t.type({
+	link_type: t.literal("Any"),
+})
+
+export const ImportLink = ImportContent(
+	"Link",
+	DefaultOrElse<
+		TypeOf<typeof AnyLink>,
+		TypeOf<typeof Link>,
+		OutputOf<typeof Link>
+	>(AnyLink)(Link),
+)
+export type ImportLink = TypeOf<typeof ImportLink>

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

@@ -1,41 +1,80 @@
 import type { NestableWidget } from "../../../../customtypes"
-import { ImportDate, ImportTimestamp } from "."
+import { ImportBoolean } from "./Boolean"
 import { ImportColor } from "./Color"
+import { ImportDate } from "./Date"
+import { ImportEmbed } from "./Embed"
+import { ImportGeoPoint } from "./GeoPoint"
+import { ImportImage } from "./Image"
+import { ImportLink } from "./Link"
 import { ImportNumber } from "./Number"
 import { ImportSelect } from "./Select"
 import { ImportText } from "./Text"
+import { ImportTimestamp } from "./Timestamp"
 
 export type ImportNestable =
+	| ImportBoolean
 	| ImportColor
-	| ImportSelect
 	| ImportNumber
+	| ImportSelect
 	| ImportText
 	| ImportDate
 	| ImportTimestamp
+	| ImportEmbed
+	| ImportLink
+	| ImportGeoPoint
+	| ImportImage
 
-export const isNestableFieldValue = (u: unknown): u is ImportNestable =>
-	ImportColor.is(u) ||
-	ImportSelect().is(u) ||
-	ImportNumber().is(u) ||
-	ImportText.is(u) ||
-	ImportDate.is(u) ||
-	ImportTimestamp.is(u)
+export const ImportNestable = {
+	is(u: unknown): u is ImportNestable {
+		return (
+			ImportBoolean.is(u) ||
+			ImportColor.is(u) ||
+			ImportNumber().is(u) ||
+			ImportSelect().is(u) ||
+			ImportText.is(u) ||
+			ImportDate.is(u) ||
+			ImportTimestamp.is(u) ||
+			ImportEmbed.is(u) ||
+			ImportLink.is(u) ||
+			ImportGeoPoint.is(u) ||
+			ImportImage().is(u)
+		)
+	},
+	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
+					default:
+						throw new Error(`Unsupported type of nestable field ${field.type}`)
+				}
+			})()
 
-export function getNestableFieldCodec(field: NestableWidget) {
-	switch (field.type) {
-		case "Color":
-			return ImportColor
-		case "Select":
-			return ImportSelect(field.config)
-		case "Number":
-			return ImportNumber(field.config)
-		case "Text":
-			return ImportText
-		case "Date":
-			return ImportDate
-		case "Timestamp":
-			return ImportTimestamp
-		default:
-			throw new Error(`Unsupported type of nestable field ${field.type}`)
-	}
+			return {
+				codec,
+				result: codec.decode(content),
+			}
+		}
+	},
 }

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

@@ -1,36 +1,38 @@
 import * as t from "io-ts"
 
-import type { NumberConfig } from "../../../../customtypes"
-import { NullOrT, Number } from "../../../../validators"
-import type { ImportFieldOutput } from ".."
+import type {
+	Number as NumberField,
+	NumberConfig,
+} from "../../../../customtypes"
+import { NullOrElse, Number } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
 
-export type ImportNumber = ImportFieldOutput<"Number", number>
-export const ImportNumber = (config?: NumberConfig) =>
-	NullOrT<number, ImportNumber>(
-		Number.pipe(
-			new t.Type<number, number, number>(
-				"ImportColorField",
-				(u: unknown): u is number => Number.is(u),
-				(n: number, c: t.Context) => {
-					const min = config?.min
-					const max = config?.max
+const numberValue = (config?: NumberConfig) =>
+	Number.pipe(
+		new t.Type<number, number, number>(
+			"ImportNumberValue",
+			(u: unknown): u is number => Number.is(u),
+			(n: number, c: t.Context) => {
+				const min = config?.min
+				const max = config?.max
 
-					if (
-						(min !== undefined && n < min) ||
-						(max !== undefined && n > max)
-					) {
-						return t.failure(
-							n,
-							c,
-							`The value must be between [${min !== undefined ? min : ""}, ${
-								max !== undefined ? max : ""
-							}]`,
-						)
-					}
+				if ((min !== undefined && n < min) || (max !== undefined && n > max)) {
+					return t.failure(
+						n,
+						c,
+						`The value must be between [${min !== undefined ? min : ""}, ${
+							max !== undefined ? max : ""
+						}]`,
+					)
+				}
 
-					return t.success(n)
-				},
-				t.identity,
-			),
+				return t.success(n)
+			},
+			t.identity,
 		),
-	)((n: number | null) => ({ type: "Number", value: n }))
+	)
+
+export const ImportNumber = (field?: NumberField) =>
+	ImportContent("Number", NullOrElse(numberValue(field?.config)))
+
+export type ImportNumber = t.TypeOf<ReturnType<typeof ImportNumber>>

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

@@ -1,36 +1,38 @@
 import * as t from "io-ts"
 
-import type { SelectConfig } from "../../../../customtypes"
-import { NullOrT, String } from "../../../../validators"
-import type { ImportFieldOutput } from ".."
+import type { Select, SelectConfig } from "../../../../customtypes"
+import { NullOrElse, String } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
 
-export type ImportSelect = ImportFieldOutput<"Select", string>
-export const ImportSelect = (config?: SelectConfig) =>
-	NullOrT<string, ImportSelect>(
-		String.pipe(
-			new t.Type<string, string, string>(
-				"ImportColorField",
-				(u: unknown): u is string => String.is(u),
-				(s: string, c: t.Context) => {
-					if (!config?.options) {
-						return t.failure(
-							s,
-							c,
-							"The value must be defined in the custom type's configuration of the field",
-						)
-					}
+const selectValue = (config?: SelectConfig) =>
+	String.pipe(
+		new t.Type<string, string, string>(
+			"ImportSelectValue",
+			(u: unknown): u is string => String.is(u),
+			(s: string, c: t.Context) => {
+				if (!config?.options) {
+					return t.failure(
+						s,
+						c,
+						"The value must be defined in the custom type's configuration of the field",
+					)
+				}
 
-					if (!config.options.includes(s)) {
-						return t.failure(
-							s,
-							c,
-							`The value must be one of these: ${config.options?.join(",")}`,
-						)
-					}
+				if (!config.options.includes(s)) {
+					return t.failure(
+						s,
+						c,
+						`The value must be one of these: ${config.options?.join(",")}`,
+					)
+				}
 
-					return t.success(s)
-				},
-				t.identity,
-			),
+				return t.success(s)
+			},
+			t.identity,
 		),
-	)((s: string | null) => ({ type: "Select", value: s }))
+	)
+
+export const ImportSelect = (field?: Select) =>
+	ImportContent("Select", NullOrElse(selectValue(field?.config)))
+
+export type ImportSelect = t.TypeOf<ReturnType<typeof ImportSelect>>

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

@@ -1,7 +1,7 @@
-import { NullOrT, String } from "../../../../validators"
-import type { ImportFieldOutput } from ".."
+import type { TypeOf } from "io-ts"
 
-export type ImportText = ImportFieldOutput<"Text", string>
-export const ImportText = NullOrT<string, ImportText>(String)(
-	(s: string | null) => ({ type: "Text", value: s }),
-)
+import { NullOrElse, String } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
+
+export const ImportText = ImportContent("Text", NullOrElse(String))
+export type ImportText = TypeOf<typeof ImportText>

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

@@ -2,35 +2,38 @@ import { chain } from "fp-ts/Either"
 import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
-import { NullOrT, String } from "../../../../validators"
-import type { ImportFieldOutput } from ".."
+import { NullOrElse, String } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
 
 export const TIMESTAMP_INPUT_REGEX =
 	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:(?:[+-]{1}\d{2}:?\d{2})|Z)$/
 
-export type ImportTimestamp = ImportFieldOutput<"Timestamp", Date>
-export const ImportTimestamp = NullOrT<Date, ImportTimestamp>(
-	new t.Type<Date, Date, unknown>(
-		"ImportDate",
-		(u: unknown): u is Date => u instanceof Date,
-		(u: unknown, c: t.Context) =>
-			pipe(
-				String.validate(u, c),
-				chain((s: string) => {
-					const date = new Date(s)
-					const isInvalidDate = isNaN(date.getTime())
+const timestampValue = new t.Type<Date, Date, unknown>(
+	"ImportTimestampValue",
+	(u: unknown): u is Date => u instanceof Date,
+	(u: unknown, c: t.Context) =>
+		pipe(
+			String.validate(u, c),
+			chain((s: string) => {
+				const date = new Date(s)
+				const isInvalidDate = isNaN(date.getTime())
 
-					if (isInvalidDate || !TIMESTAMP_INPUT_REGEX.test(s)) {
-						return t.failure(
-							u,
-							c,
-							"The value must be a DateTime in the format YYYY-MM-DDTHH:MM:SS+0000",
-						)
-					}
+				if (isInvalidDate || !TIMESTAMP_INPUT_REGEX.test(s)) {
+					return t.failure(
+						u,
+						c,
+						"The value must be a DateTime in the format YYYY-MM-DDTHH:MM:SS+0000",
+					)
+				}
 
-					return t.success(date)
-				}),
-			),
-		t.identity,
-	),
-)((s: Date | null) => ({ type: "Timestamp", value: s }))
+				return t.success(date)
+			}),
+		),
+	t.identity,
+)
+
+export const ImportTimestamp = ImportContent(
+	"Timestamp",
+	NullOrElse(timestampValue),
+)
+export type ImportTimestamp = t.TypeOf<typeof ImportTimestamp>

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

@@ -1,5 +1,11 @@
+export * from "./Boolean"
 export * from "./Color"
 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"
 export * from "./Select"

package/src/utils/DocumentId.ts

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

package/src/utils/Objects.ts

@@ -41,3 +41,13 @@ const recordCodec = t.record(t.string, t.unknown)
 export function isObject(value: unknown): value is Record<string, unknown> {
 	return isRight(recordCodec.decode(value))
 }
+
+export function mapValues<T, O>(
+	record: Record<string, T>,
+	fn: (value: T, key: string) => O,
+): Record<string, O> {
+	return Object.entries<T>(record).reduce<Record<string, O>>(
+		(acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }),
+		{},
+	)
+}