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

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 { Asset } from "../../../../common"
+import type { Embed } from "../../../../common/Embed"
 import type { WidgetContent } 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,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
 ): WidgetContent | 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,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>