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

package/src/import/validators/Document.ts

@@ -1,96 +1,111 @@
-import * as Either from "fp-ts/Either"
+import { either } from "fp-ts"
+import { Either, isLeft } from "fp-ts/Either"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
 
 import type { WidgetKey } from "../../common"
-import {
-	isNestableWidget,
-	StaticCustomType,
-	StaticWidget,
-} from "../../customtypes"
+import type { StaticCustomType, StaticWidget } from "../../customtypes"
 import { isObject } from "../../utils/Objects"
-import { getNestableFieldCodec, ImportNestable } from "./fields"
+import { ImportField } from "./fields/ImportField"
 
-export type ImportDocument = Record<WidgetKey, ImportNestable>
-export const ImportDocument = (mask: StaticCustomType) =>
-	new t.Type<ImportDocument, ImportDocument, unknown>(
-		"ImportDocument",
-		(u): u is ImportDocument => isObject(u),
-		(raw: unknown) => {
-			if (!isObject(raw)) {
-				const error: t.ValidationError = {
-					value: raw,
-					context: [],
-					message: "document is not an object",
-				}
-				return Either.left([error])
-			}
-
-			// flattening the fields within the tabs
-			const maskFields = Object.values(mask.json).reduce((acc, tab) => ({
-				...acc,
-				...tab,
-			}))
-
-			// Listing all errors for each fields
-			const { document, errors } = Object.entries(raw).reduce<{
-				document: ImportDocument
-				errors: t.Errors
-			}>(
-				(acc, [fieldKey, fieldValue]) => {
-					const maskFieldValue = maskFields[fieldKey]
+const rawImportDocument = withMessage(
+	t.record(t.string, t.unknown),
+	() => "document is not an object",
+)
 
-					// the field is not defined in the custom type -> extra field or typo
-					if (!maskFieldValue) {
-						const error: t.ValidationError = {
-							value: fieldValue,
-							context: [{ key: fieldKey, type: t.unknown }],
-							message: `The field ${fieldKey} is not part of the Custom type`,
-						}
-						return { ...acc, errors: [...acc.errors, error] }
-					}
+function flattenCustomTypeFields(
+	customType: StaticCustomType,
+): Partial<Record<string, StaticWidget>> {
+	return Object.values(customType.json).reduce((acc, tab) => ({
+		...acc,
+		...tab,
+	}))
+}
 
-					// retrieving the right codec then testing out fieldValue with it.
-					const fieldCodec = getFieldCodec(maskFieldValue)
-					const result = fieldCodec.decode(fieldValue)
+function validateField(
+	document: Record<string, unknown>,
+	customType: StaticCustomType,
+) {
+	return (
+		key: string,
+		content: unknown,
+		model?: StaticWidget,
+	): Either<t.Errors, ImportField> => {
+		// the field is not defined in the custom type -> extra field or typo
+		if (!model) {
+			const error: t.ValidationError = {
+				value: content,
+				context: [{ key: key, type: t.unknown }],
+				message: `The field ${key} is not part of the Custom type`,
+			}
+			return either.left([error])
+		}
 
-					// returning validation errors
-					if (Either.isLeft(result)) {
-						// error.context is pointing at root when it should point to a `fieldKey`.
-						// We need to override the context to make it right.
-						const errors: t.Errors = result.left.map(error => {
-							const contextHead = error.context[0];
-							const context = [
-								{ key: '', actual: raw, type: ImportDocument(mask) },
-								contextHead
-									? { ...contextHead, key: fieldKey }
-									: {key: fieldKey, actual: fieldValue, type: fieldCodec},
-								...error.context.slice(1)
-							];
+		// retrieving the right codec then testing out fieldValue with it.
+		const { result, codec } = ImportField.decode(model)(content)
 
-							return { ...error, context };
-						});
+		// error.context is pointing at root when it should point to a `fieldKey`.
+		// We need to override the context to make it right.
+		if (isLeft(result)) {
+			const errors: t.Errors = result.left.map((error) => {
+				const contextHead = error.context[0]
+				const context = [
+					{ key: "", actual: document, type: ImportDocument(customType) },
+					contextHead
+						? { ...contextHead, key: key }
+						: { key: key, actual: content, type: codec },
+					...error.context.slice(1),
+				]
 
-						return { ...acc, errors: [...acc.errors, ...errors] };
-					}
+				return { ...error, context }
+			})
+			return either.left(errors)
+		}
+		return either.right(result.right)
+	}
+}
 
-					// registering the field as validated
-					return {
-						...acc,
-						document: { ...acc.document, [fieldKey]: result.right },
-					}
-				},
-				{ document: {}, errors: [] },
+function validateDocument(
+	customType: StaticCustomType,
+	rawDoc: Record<string, unknown>,
+) {
+	const fieldModels = flattenCustomTypeFields(customType)
+	const { document, errors } = Object.entries(rawDoc).reduce<{
+		document: ImportDocument
+		errors: t.Errors
+	}>(
+		(acc, [fieldKey, fieldValue]) => {
+			const parsedField = validateField(rawDoc, customType)(
+				fieldKey,
+				fieldValue,
+				fieldModels[fieldKey],
 			)
 
-			// Returning either the errors of
-			if (errors.length > 0) return Either.left(errors)
-			return Either.right(document)
+			if (isLeft(parsedField))
+				return { ...acc, errors: [...acc.errors, ...parsedField.left] }
+
+			return {
+				...acc,
+				document: { ...acc.document, [fieldKey]: parsedField.right },
+			}
 		},
-		t.identity,
+		{ document: {}, errors: [] },
 	)
-
-function getFieldCodec(maskValue: StaticWidget) {
-	if (isNestableWidget(maskValue)) return getNestableFieldCodec(maskValue)
-	throw new Error(`Unsupported type of field ${maskValue.type}`)
+	if (errors.length > 0) return either.left(errors)
+	return either.right(document)
 }
 
+export type ImportDocument = Record<WidgetKey, ImportField>
+export const ImportDocument = (customType: StaticCustomType) =>
+	new t.Type<ImportDocument, ImportDocument, unknown>(
+		"ImportDocument",
+		(u): u is ImportDocument => isObject(u),
+		(raw: unknown) => {
+			return pipe(
+				rawImportDocument.decode(raw),
+				either.chain((doc) => validateDocument(customType, doc)),
+			)
+		},
+		t.identity,
+	)

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

@@ -0,0 +1,30 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import type { FieldType } from "../../../customtypes"
+import { isObject } from "../../../utils/Objects"
+
+export const ImportContent = <T extends FieldType, A, O = A>(
+	type: T,
+	valueCodec: t.Type<A, O>,
+) =>
+	new t.Type<{ type: T; value: A }, O>(
+		"ImportField",
+		(u: unknown): u is { type: T; value: A } => {
+			if (!isObject(u)) return false
+			return type === u["type"] && valueCodec.is(u["value"])
+		},
+		(u: unknown) => {
+			return pipe(
+				valueCodec.decode(u),
+				either.map((decodedValue) => {
+					return {
+						type,
+						value: decodedValue,
+					}
+				}),
+			)
+		},
+		(field) => field.value as unknown as O,
+	)

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

@@ -0,0 +1,25 @@
+import type { StaticWidget } from "../../../customtypes"
+import { ImportNestable } from "./nestable"
+import { ImportUID } from "./UID"
+
+export type ImportField = ImportUID | ImportNestable
+
+export const ImportField = {
+	is(u: unknown): u is ImportNestable {
+		return ImportUID.is(u) || ImportNestable.is(u)
+	},
+	decode: (field: StaticWidget) => {
+		return (content: unknown) => {
+			switch (field.type) {
+				case "UID":
+					return { codec: ImportUID, result: ImportUID.decode(content) }
+				case "Choice":
+				case "Slices":
+				case "Group":
+					throw new Error(`Unsupported type of field ${field.type}`)
+				default:
+					return ImportNestable.decode(field)(content)
+			}
+		}
+	},
+}

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

@@ -0,0 +1,27 @@
+import * as t from "io-ts"
+
+import { NullOrElse, String } from "../../../validators"
+import { ImportContent } from "./ImportContent"
+
+const regex = /^[a-z0-9-_.]+$/
+
+const uidValue = String.pipe(
+	new t.Type<string, string, string>(
+		"ImportUIDField",
+		(u: unknown): u is string => String.is(u),
+		(n: string, c: t.Context) => {
+			if (regex.test(n)) {
+				return t.success(n)
+			}
+			return t.failure(
+				n,
+				c,
+				"UID can only contain alphanumeric characters, dashes, underscores, and dots",
+			)
+		},
+		t.identity,
+	),
+)
+
+export const ImportUID = ImportContent("UID", NullOrElse(uidValue))
+export type ImportUID = t.TypeOf<typeof ImportUID>

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

@@ -1,8 +1,2 @@
-import type { FieldType } from "../../../customtypes"
-
 export * from "./nestable"
-
-export interface ImportFieldOutput<t extends FieldType, v, d = null> {
-	type: t
-	value: v | d
-}
+export * from "./UID"

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

@@ -0,0 +1,7 @@
+import type { TypeOf } from "io-ts"
+
+import { Boolean, NullOrElse } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
+
+export const ImportBoolean = ImportContent("Boolean", NullOrElse(Boolean))
+export type ImportBoolean = TypeOf<typeof ImportBoolean>

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

@@ -1,28 +1,28 @@
 import * as t from "io-ts"
 
 import { HexaColor, HexaColorCode } from "../../../../common/HexaColorCode"
-import { NullOrT, String } from "../../../../validators"
-import type { ImportFieldOutput } from ".."
+import { NullOrElse, String } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
 
-export type ImportColor = ImportFieldOutput<"Color", HexaColorCode>
-export const ImportColor = NullOrT<HexaColorCode, ImportColor>(
-	// @ts-expect-error HexaColorCode is not inferred as a string.
-	String.pipe(
-		new t.Type<HexaColorCode, HexaColorCode, string>(
-			"ImportColorField",
-			(u: unknown): u is HexaColorCode => String.is(u) && HexaColor.is(u),
-			(s: string, c: t.Context) => {
-				if (!HexaColor.is(s)) {
-					return t.failure(
-						s,
-						c,
-						"The color value must be an hexadecimal color code",
-					)
-				}
+const colorValue = new t.Type<HexaColorCode, HexaColorCode, string>(
+	"ImportColorValue",
+	(u: unknown): u is HexaColorCode => String.is(u) && HexaColor.is(u),
+	(s: string, c: t.Context) => {
+		if (!HexaColor.is(s)) {
+			return t.failure(
+				s,
+				c,
+				"The color value must be an hexadecimal color code",
+			)
+		}
 
-				return t.success(s)
-			},
-			t.identity,
-		),
-	),
-)((s: HexaColorCode | null) => ({ type: "Color", value: s }))
+		return t.success(s)
+	},
+	t.identity,
+)
+
+export const ImportColor = ImportContent(
+	"Color",
+	NullOrElse(String.pipe(colorValue)),
+)
+export type ImportColor = t.TypeOf<typeof ImportColor>

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

@@ -2,34 +2,33 @@ 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"
 const DATE_INPUT_REGEX = /^(\d{1,4})-(\d{1,2})-(\d{1,2})$/
 
-export type ImportDate = ImportFieldOutput<"Date", Date>
-export const ImportDate = NullOrT<Date, ImportDate>(
-	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 dateValue = new t.Type<Date, Date, unknown>(
+	"ImportNumberValue",
+	(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 || !DATE_INPUT_REGEX.test(s)) {
+					return t.failure(
+						u,
+						c,
+						"The value must be a Date in the format YYYY-MM-DD",
+					)
+				}
 
-					if (isInvalidDate || !DATE_INPUT_REGEX.test(s)) {
-						return t.failure(
-							u,
-							c,
-							"The value must be a Date in the format YYYY-MM-DD",
-						)
-					}
+				return t.success(date)
+			}),
+		),
+	t.identity,
+)
 
-					return t.success(date)
-				}),
-			),
-		t.identity,
-	),
-)((s: Date | null) => ({ type: "Date", value: s }))
+export const ImportDate = ImportContent("Date", NullOrElse(dateValue))
+export type ImportDate = t.TypeOf<typeof ImportDate>

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

@@ -0,0 +1,86 @@
+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
+
+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.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>
+
+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(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 { 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.ts

@@ -0,0 +1,77 @@
+import { chain, map } from "fp-ts/Either"
+import { pipe } from "fp-ts/lib/function"
+import type { Validation } from "io-ts"
+import * as t from "io-ts"
+
+import { withOptionals } from "../../../../utils/Objects"
+import { AnyObject, NullOrElse, Number } from "../../../../validators"
+import { String, StringOrNull } from "../../../../validators/BasicTypes"
+import { ImportContent } from "../ImportContent"
+
+const ImageFieldCodec = AnyObject.pipe(
+	t.intersection([
+		t.type({
+			id: String,
+		}),
+		t.partial({
+			edit: AnyObject.pipe(
+				t.strict({
+					x: Number,
+					y: Number,
+					width: Number,
+					height: Number,
+					zoom: Number,
+					background: String,
+				}),
+			),
+			credit: StringOrNull,
+			alt: StringOrNull,
+		}),
+	]),
+)
+
+const ThumbnailsCodec = t.record(t.string, ImageFieldCodec)
+type Thumbnails = t.TypeOf<typeof ThumbnailsCodec>
+
+export type ImageField = t.TypeOf<typeof ImageFieldCodec>
+
+type ImageFieldWithThumbnails = ImageField & { thumbnails: Thumbnails }
+
+const ImageFieldWithThumbnails = new t.Type(
+	"ImageFieldWithThumbnails",
+	(u: unknown): u is ImageFieldWithThumbnails =>
+		ImageFieldCodec.is(u) &&
+		"thumbnails" in u &&
+		ThumbnailsCodec.is(u["thumbnails"]),
+	(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
+		return pipe(
+			ImageFieldCodec.validate(u, ctx),
+			chain((proto) => {
+				const { id, edit, credit, alt, ...maybeThumbnails } = proto
+				return pipe(
+					ThumbnailsCodec.validate(maybeThumbnails, ctx),
+					map((thumbnails) =>
+						withOptionals<ImageFieldWithThumbnails>(
+							{
+								id,
+								thumbnails,
+							},
+							[
+								["edit", edit],
+								["credit", credit],
+								["alt", alt],
+							],
+						),
+					),
+				)
+			}),
+		)
+	},
+	t.identity,
+)
+
+export const ImportImage = ImportContent(
+	"Image",
+	NullOrElse(ImageFieldWithThumbnails),
+)
+export type ImportImage = t.TypeOf<typeof ImportImage>