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

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,37 @@
+import type { Embed } from "../../../../common"
+import { getEmbedOrThrow } from "../../../../common"
+import type { EmbedContent } from "../../../../content"
+import { withOptionals } from "../../../../utils/Objects"
+import type { ImportEmbed } from "../../../validators"
+
+export const embedConverter = (
+	field: ImportEmbed["value"],
+	embeds: Record<string, Embed | undefined>,
+): EmbedContent | undefined => {
+	if (field === null) return
+	const embed = getEmbedOrThrow(embeds)(field.embed_url)
+	return withOptionals<EmbedContent>(
+		{
+			embed_url: field.embed_url,
+			type: embed.type,
+			all: {
+				embed_url: field.embed_url,
+				...embed,
+			},
+			__TYPE__: "EmbedContent",
+		},
+		[
+			["version", embed.version],
+			["title", embed.title],
+			["author_name", embed.author_name],
+			["author_url", embed.author_url],
+			["provider_name", embed.provider_name],
+			["provider_url", embed.provider_url],
+			["cache_age", embed.cache_age],
+			["thumbnail_url", embed.thumbnail_url],
+			["thumbnail_width", embed.thumbnail_width],
+			["thumbnail_height", embed.thumbnail_height],
+			["html", embed.html],
+		],
+	)
+}

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

@@ -0,0 +1,16 @@
+import type { GeoPointContent } from "../../../../content"
+import type { ImportGeoPoint } from "../../../validators"
+
+export const geopointConverter = (
+	field: ImportGeoPoint["value"],
+): GeoPointContent | undefined => {
+	if (field === null) return
+
+	return {
+		position: {
+			lat: field.latitude,
+			lng: field.longitude,
+		},
+		__TYPE__: "GeoPointContent",
+	}
+}

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

@@ -0,0 +1,73 @@
+import type { Asset } from "../../../../common"
+import { getAssetOrThrow } from "../../../../common"
+import type { ImageContent } from "../../../../content"
+import { withOptionals } from "../../../../utils/Objects"
+import type { ImageField, ImportImage } from "../../../validators"
+
+function convertImage(imageField: ImageField, image: Asset) {
+	return withOptionals<Omit<ImageContent, "__TYPE__" | "thumbnails">>(
+		{
+			origin: {
+				id: image.id,
+				url: image.origin_url,
+				// All images returned form Asset API should have width and height properties.
+				width: image.width ?? 0,
+				height: image.height ?? 0,
+			},
+			// All images returned form Asset API should have width and height properties.
+			// Image width and height will be only applied if there are no constraints and user didn't overwrite it
+			width: imageField?.dimensions?.width ?? image.width ?? 0,
+			height: imageField?.dimensions?.height ?? image.height ?? 0,
+			// If edit is not provided, we crop constraint width and height from the left upper corner.
+			// WARN: If constraints are greater than image dimensions cut outside the image (background will fill extra space).
+			edit: {
+				zoom: imageField.edit?.zoom ?? 1,
+				crop: {
+					x: imageField.edit?.x ?? 0,
+					y: imageField.edit?.y ?? 0,
+				},
+				background:
+					imageField.edit?.background ??
+					(image.extension === "png" ? "transparent" : "#ffffff"),
+			},
+			url: image.url,
+		},
+		[
+			["alt", imageField?.alt || image.alt],
+			["credits", imageField?.credit || image.credits],
+		],
+	)
+}
+
+function convertThumbnails(
+	imageField: Exclude<ImportImage["value"], null>,
+	assets: Record<Asset["id"], Asset | undefined>,
+) {
+	return Object.entries(imageField.thumbnails).reduce(
+		(acc, [thumbnailName, thumbnail]) => {
+			return {
+				...acc,
+				[thumbnailName]: convertImage(
+					thumbnail,
+					getAssetOrThrow(assets)(thumbnail.id),
+				),
+			}
+		},
+		{},
+	)
+}
+
+// All assets from `imageField` must be present in `assets`
+// If not then function will throw an error
+export const imageConverter = (
+	imageField: ImportImage["value"],
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageContent | undefined => {
+	if (!imageField) return
+
+	return {
+		...convertImage(imageField, getAssetOrThrow(assets)(imageField.id)),
+		thumbnails: convertThumbnails(imageField, assets),
+		__TYPE__: "ImageContent" as const,
+	}
+}

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

@@ -0,0 +1,77 @@
+import type { Asset } from "../../../../common"
+import { getAssetOrThrow } from "../../../../common"
+import type { LinkContent } from "../../../../content"
+import type {
+	DocumentLink,
+	ImportLink,
+	MediaLink,
+	WebLink,
+} from "../../../validators"
+
+const webLinkConverter = (field: WebLink): LinkContent => ({
+	value: {
+		url: field.url,
+		target: field.target,
+		__TYPE__: "ExternalLink",
+	},
+	__TYPE__: "LinkContent",
+})
+
+const documentLinkConverter = (field: DocumentLink): LinkContent => ({
+	value: {
+		id: field.id,
+		__TYPE__: "DocumentLink",
+	},
+	__TYPE__: "LinkContent",
+})
+
+const fileLinkConverter = (field: MediaLink, asset: Asset): LinkContent => ({
+	value: {
+		id: field.id,
+		url: asset.url,
+		name: asset.filename ?? "unknown.jpg",
+		kind: asset.kind,
+		size: asset.size ?? "0",
+		__TYPE__: "FileLink",
+	},
+	__TYPE__: "LinkContent",
+})
+
+const imageLinkConverter = (field: MediaLink, asset: Asset): LinkContent => ({
+	value: {
+		id: field.id,
+		url: asset.url,
+		height: String(asset.height ?? 1),
+		width: String(asset.width ?? 1),
+		name: asset.filename ?? "unknown.jpg",
+		kind: asset.kind,
+		size: asset.size ?? "0",
+		__TYPE__: "ImageLink",
+	},
+	__TYPE__: "LinkContent",
+})
+
+export const linkConverter = (
+	field: ImportLink["value"],
+	assets: Record<string, Asset | undefined>,
+): LinkContent | undefined => {
+	if (field === null) {
+		return
+	}
+
+	switch (field.link_type) {
+		case "Web":
+			return webLinkConverter(field)
+		case "Document":
+			return documentLinkConverter(field)
+		case "Media": {
+			const asset = getAssetOrThrow(assets)(field.id)
+			switch (asset.kind) {
+				case "all":
+					return fileLinkConverter(field, asset)
+				case "image":
+					return imageLinkConverter(field, asset)
+			}
+		}
+	}
+}

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

@@ -1,8 +1,15 @@
-import type { WidgetContent } from "../../../../content"
+import type { Asset } from "../../../../common"
+import type { Embed } from "../../../../common/Embed"
+import type { NestableContent } from "../../../../content"
 import type { ImportNestable } from "../../../validators"
 import {
+	booleanConverter,
 	colorConverter,
 	dateConverter,
+	embedConverter,
+	geopointConverter,
+	imageConverter,
+	linkConverter,
 	numberConverter,
 	selectConverter,
 	textConverter,
@@ -11,8 +18,12 @@ import {
 
 export function convertNestableWidget(
 	field: ImportNestable,
-): WidgetContent | undefined {
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): NestableContent | undefined {
 	switch (field.type) {
+		case "Boolean":
+			return booleanConverter(field.value)
 		case "Color":
 			return colorConverter(field.value)
 		case "Select":
@@ -25,6 +36,14 @@ export function convertNestableWidget(
 			return dateConverter(field.value)
 		case "Timestamp":
 			return timestampConverter(field.value)
+		case "Embed":
+			return embedConverter(field.value, embeds)
+		case "GeoPoint":
+			return geopointConverter(field.value)
+		case "Link":
+			return linkConverter(field.value, assets)
+		case "Image":
+			return imageConverter(field.value, assets)
 		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,10 @@
+export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
+export * from "./Embed"
+export * from "./GeooPoint"
+export * from "./Image"
+export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"
 export * from "./Select"

package/src/import/validators/Document.ts

@@ -1,96 +1,103 @@
-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 { flattenCustomTypeFields } 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 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])
+		}
 
-			// 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]
+		// retrieving the right codec then testing out fieldValue with it.
+		const { result, codec } = ImportField.decode(model)(content)
 
-					// 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] }
-					}
+		// 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),
+				]
 
-					// retrieving the right codec then testing out fieldValue with it.
-					const fieldCodec = getFieldCodec(maskFieldValue)
-					const result = fieldCodec.decode(fieldValue)
+				return { ...error, context }
+			})
+			return either.left(errors)
+		}
+		return either.right(result.right)
+	}
+}
 
-					// 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)
-							];
+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],
+			)
 
-							return { ...error, context };
-						});
+			if (isLeft(parsedField))
+				return { ...acc, errors: [...acc.errors, ...parsedField.left] }
 
-						return { ...acc, errors: [...acc.errors, ...errors] };
-					}
+			return {
+				...acc,
+				document: { ...acc.document, [fieldKey]: parsedField.right },
+			}
+		},
+		{ document: {}, errors: [] },
+	)
+	if (errors.length > 0) return either.left(errors)
+	return either.right(document)
+}
 
-					// registering the field as validated
-					return {
-						...acc,
-						document: { ...acc.document, [fieldKey]: result.right },
-					}
-				},
-				{ document: {}, errors: [] },
+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)),
 			)
-
-			// Returning either the errors of
-			if (errors.length > 0) return Either.left(errors)
-			return Either.right(document)
 		},
 		t.identity,
 	)
-
-function getFieldCodec(maskValue: StaticWidget) {
-	if (isNestableWidget(maskValue)) return getNestableFieldCodec(maskValue)
-	throw new Error(`Unsupported type of field ${maskValue.type}`)
-}
-

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,30 @@
+import type { StaticWidget } from "../../../customtypes"
+import { ImportSlices } from "./ImportSlices"
+import { ImportNestable } from "./nestable"
+import { ImportUID } from "./UID"
+
+export type ImportField = ImportUID | ImportSlices | 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 "Slices":
+					return {
+						codec: ImportSlices(field),
+						result: ImportSlices(field).decode(content),
+					}
+				case "Choice":
+				case "Group":
+					throw new Error(`Unsupported type of field ${field.type}`)
+				default:
+					return ImportNestable.decode(field)(content)
+			}
+		}
+	},
+}