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

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

@@ -0,0 +1,13 @@
+import type { UIDContent } from "../../../content"
+import type { ImportUID } from "../../validators/fields/UID"
+
+export const uidConverter = (
+	field: ImportUID["value"],
+): UIDContent | undefined => {
+	if (field === null) return
+
+	return {
+		value: field,
+		__TYPE__: "UIDContent",
+	}
+}

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

@@ -1 +1,2 @@
 export * from "./nestable"
+export * from "./UID"

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

@@ -0,0 +1,13 @@
+import type { BooleanContent } from "../../../../content"
+import type { ImportBoolean } from "../../../validators"
+
+export const booleanConverter = (
+	field: ImportBoolean["value"],
+): BooleanContent | undefined => {
+	if (field === null) return
+
+	return {
+		value: field,
+		__TYPE__: "BooleanContent",
+	}
+}

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

@@ -1,12 +1,14 @@
 import type { ColorContent } from "../../../../content"
 import type { ImportColor } from "../../../validators"
-import { nullableConverter } from "../utils"
 
 export const colorConverter = (
 	field: ImportColor["value"],
-): ColorContent | undefined =>
-	nullableConverter(field, (value: NonNullable<ImportColor["value"]>) => ({
+): ColorContent | undefined => {
+	if (field === null) return
+
+	return {
 		type: "Color",
-		value: value,
+		value: field,
 		__TYPE__: "FieldContent",
-	}))
+	}
+}

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

@@ -1,18 +1,17 @@
 import type { DateContent } from "../../../../content"
-import type { ImportDate } from "../../.."
-import { nullableConverter } from "../utils"
+import type { ImportDate } from "../../../validators"
 
 export const dateConverter = (
 	field: ImportDate["value"],
-): DateContent | undefined =>
-	nullableConverter(field, (value: NonNullable<ImportDate["value"]>) => {
-		// Iso date looks like this '2023-07-10T13:33:12+0000'
-		const isoDate = value.toISOString()
-		const [withoutTime] = isoDate.split("T")
+): DateContent | undefined => {
+	if (field === null) return
 
-		return {
-			type: "Date",
-			value: withoutTime || isoDate,
-			__TYPE__: "FieldContent",
-		}
-	})
+	const isoDate = field.toISOString()
+	const [withoutTime] = isoDate.split("T")
+
+	return {
+		type: "Date",
+		value: withoutTime || isoDate,
+		__TYPE__: "FieldContent",
+	}
+}

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

@@ -0,0 +1,15 @@
+import type { EmbedContent } from "../../../../content"
+import type { ImportEmbed } from "../../../validators"
+
+export const embedConverter = (
+	field: ImportEmbed["value"],
+): EmbedContent | undefined => {
+	if (field === null) return
+
+	return {
+		...field,
+		__TYPE__: "EmbedContent",
+	}
+
+	return
+}

package/src/import/converters/fields/nestable/Image.ts

@@ -0,0 +1,68 @@
+import type { ImageContent } from "../../../../content"
+import { mapValues, withOptionals } from "../../../../utils/Objects"
+import type { ImageField, ImportImage } from "../../../validators"
+
+export type Asset = {
+	id: string
+	last_modified: string
+	kind: "image" | "all"
+	filename?: string
+	extension?: string
+	size?: string
+	origin_url: string
+	url: string
+	width?: number
+	height?: number
+	notes?: string
+	credits?: string
+	alt?: string
+}
+
+function convertImage(field: ImageField, image: Asset) {
+	return withOptionals<Omit<ImageContent, "__TYPE__" | "thumbnails">>(
+		{
+			origin: {
+				id: field.id,
+				url: image.origin_url,
+				width: image.width!,
+				height: image.height!,
+			},
+			width: field.edit?.width ?? image.width!,
+			height: field.edit?.height ?? image.height!,
+			edit: {
+				zoom: field.edit?.zoom ?? 1,
+				crop: {
+					x: field.edit?.x ?? 0,
+					y: field.edit?.y ?? 0,
+				},
+				background: field.edit?.background ?? "transparent",
+			},
+			url: image.url,
+		},
+		[
+			["alt", field.alt || image.alt],
+			["credits", field.credit || image.credits],
+		],
+	)
+}
+
+export const imageConverter = (
+	field: ImportImage["value"],
+	images: Map<string, Asset>,
+): ImageContent | undefined => {
+	const getImageById = (id: string): Asset => {
+		const image = images.get(id)
+		if (!image) throw new Error(`Missing asset with id '${id}'`)
+		return image
+	}
+
+	if (!field) return
+
+	return {
+		...convertImage(field, getImageById(field.id)),
+		thumbnails: mapValues(field.thumbnails, (thumbnail) =>
+			convertImage(thumbnail, getImageById(thumbnail.id)),
+		),
+		__TYPE__: "ImageContent",
+	}
+}

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

@@ -1,8 +1,12 @@
 import type { WidgetContent } from "../../../../content"
 import type { ImportNestable } from "../../../validators"
 import {
+	Asset,
+	booleanConverter,
 	colorConverter,
 	dateConverter,
+	embedConverter,
+	imageConverter,
 	numberConverter,
 	selectConverter,
 	textConverter,
@@ -11,8 +15,11 @@ import {
 
 export function convertNestableWidget(
 	field: ImportNestable,
+	images: Map<string, Asset>,
 ): WidgetContent | undefined {
 	switch (field.type) {
+		case "Boolean":
+			return booleanConverter(field.value)
 		case "Color":
 			return colorConverter(field.value)
 		case "Select":
@@ -25,6 +32,10 @@ export function convertNestableWidget(
 			return dateConverter(field.value)
 		case "Timestamp":
 			return timestampConverter(field.value)
+		case "Embed":
+			return embedConverter(field.value)
+		case "Image":
+			return imageConverter(field.value, images)
 		default:
 			throw new Error(
 				`Unsupported type of nestable converter ${JSON.stringify(field)}`,

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

@@ -1,12 +1,14 @@
 import type { NumberContent } from "../../../../content"
 import type { ImportNumber } from "../../../validators"
-import { nullableConverter } from "../utils"
 
 export const numberConverter = (
 	field: ImportNumber["value"],
-): NumberContent | undefined =>
-	nullableConverter(field, (value: NonNullable<ImportNumber["value"]>) => ({
+): NumberContent | undefined => {
+	if (field === null) return
+
+	return {
 		type: "Number",
-		value: value.toString(),
+		value: field.toString(),
 		__TYPE__: "FieldContent",
-	}))
+	}
+}

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

@@ -1,12 +1,14 @@
 import type { SelectContent } from "../../../../content"
 import type { ImportSelect } from "../../../validators"
-import { nullableConverter } from "../utils"
 
 export const selectConverter = (
 	field: ImportSelect["value"],
-): SelectContent | undefined =>
-	nullableConverter(field, (value: NonNullable<ImportSelect["value"]>) => ({
+): SelectContent | undefined => {
+	if (field === null) return
+
+	return {
 		type: "Select",
-		value: value,
+		value: field,
 		__TYPE__: "FieldContent",
-	}))
+	}
+}

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

@@ -1,12 +1,14 @@
 import type { TextContent } from "../../../../content"
 import type { ImportText } from "../../../validators"
-import { nullableConverter } from "../utils"
 
 export const textConverter = (
 	field: ImportText["value"],
-): TextContent | undefined =>
-	nullableConverter(field, (value: NonNullable<ImportText["value"]>) => ({
+): TextContent | undefined => {
+	if (field === null) return
+
+	return {
 		type: "Text",
-		value: value,
+		value: field,
 		__TYPE__: "FieldContent",
-	}))
+	}
+}

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

@@ -1,12 +1,14 @@
 import type { TimestampContent } from "../../../../content"
-import type { ImportTimestamp } from "../../.."
-import { nullableConverter } from "../utils"
+import type { ImportTimestamp } from "../../../validators"
 
 export const timestampConverter = (
 	field: ImportTimestamp["value"],
-): TimestampContent | undefined =>
-	nullableConverter(field, (value: NonNullable<ImportTimestamp["value"]>) => ({
+): TimestampContent | undefined => {
+	if (field === null) return
+
+	return {
 		type: "Timestamp",
-		value: value.toISOString(),
+		value: field.toISOString(),
 		__TYPE__: "FieldContent",
-	}))
+	}
+}

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

@@ -1,5 +1,8 @@
+export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
+export * from "./Embed"
+export * from "./Image"
 export * from "./Nestable"
 export * from "./Number"
 export * from "./Select"

package/src/import/validators/Document.ts

@@ -1,79 +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])
-			}
+const rawImportDocument = withMessage(
+	t.record(t.string, t.unknown),
+	() => "document is not an object",
+)
 
-			// flattening the fields within the tabs
-			const maskFields = Object.values(mask.json).reduce((acc, tab) => ({
-				...acc,
-				...tab,
-			}))
+function flattenCustomTypeFields(
+	customType: StaticCustomType,
+): Partial<Record<string, StaticWidget>> {
+	return Object.values(customType.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]
+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])
+		}
 
-					// 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] }
-					}
+		// retrieving the right codec then testing out fieldValue with it.
+		const { result, codec } = ImportField.decode(model)(content)
 
-					// retrieving the right codec then testing out fieldValue with it.
-					const fieldCodec = getFieldCodec(maskFieldValue)
-					const result = fieldCodec.decode(fieldValue)
+		// 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),
+				]
 
-					// returning validation errors
-					if (Either.isLeft(result))
-						return { ...acc, errors: [...acc.errors, ...result.left] }
+				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>