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

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

@@ -0,0 +1,54 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import type { StaticSlices } from "../../../../customtypes"
+import { EmptyObjectOrElse } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
+import { SharedSlice } from "./SharedSlice"
+import {
+	extractSupportedSlices,
+	findImportSharedSliceDuplicateIds,
+} from "./utils"
+
+export const ImportSlices = (staticSlices: StaticSlices) => {
+	const supportedSlices = extractSupportedSlices(staticSlices)
+
+	// For now we only support the SharedSlice, however if we want to support more in the future
+	// we would have to change the codec here to something like this: t.array(t.union([ImportSharedSlice(sharedSlices), NewSliceCodec(newSliceCustomTypes)])).
+	const SlicesArrayCodec = t.array(SharedSlice(supportedSlices))
+
+	return ImportContent(
+		"Slices",
+		EmptyObjectOrElse(
+			new t.Type<SharedSlice[]>(
+				"ImportSlices",
+				(u): u is SharedSlice[] => SlicesArrayCodec.is(u),
+				(u, c) => {
+					return pipe(
+						SlicesArrayCodec.validate(u, c),
+						E.chain((slices) => {
+							// This part might not make sense for all Slice types in the future, but for now we only support the SharedSlice
+							// In case we support more in the future, we would have to filter only the relevant type for this check
+							const sharedSliceDuplicates =
+								findImportSharedSliceDuplicateIds(slices)
+							if (sharedSliceDuplicates.length > 0) {
+								return t.failure(
+									slices,
+									[],
+									`Duplicate slice IDs detected: ${sharedSliceDuplicates.join(
+										", ",
+									)}`,
+								)
+							}
+							return t.success(slices)
+						}),
+					)
+				},
+				t.identity,
+			),
+		),
+	)
+}
+
+export type ImportSlices = t.TypeOf<ReturnType<typeof ImportSlices>>

package/src/import/validators/fields/ImportSlices/SharedSlice/SharedSlice.ts

@@ -0,0 +1,114 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes"
+import { AnyArray, NonEmptyString, String } from "../../../../../validators"
+import {
+	OptionalSharedSliceId,
+	SharedSliceContent,
+	SharedSliceId,
+	SharedSliceType,
+	SharedSliceVariation,
+} from "./fields"
+
+export type SharedSlice = {
+	id: SharedSliceId | null | undefined
+	slice_type: string
+	name: string
+	variation: string
+	primary: SharedSliceContent | null | undefined
+	items: SharedSliceContent[] | null | undefined
+	slice_label: string | null | undefined
+	version: string | null | undefined
+}
+
+const SharedSliceShape = t.type({
+	id: OptionalSharedSliceId,
+	slice_type: NonEmptyString,
+	name: String,
+	variation: NonEmptyString,
+	primary: t.union([t.undefined, t.null, t.record(NonEmptyString, t.unknown)]),
+	items: t.union([
+		t.undefined,
+		t.null,
+		t.array(t.record(NonEmptyString, t.unknown)),
+	]),
+	slice_label: t.union([t.undefined, t.null, String]),
+	version: t.union([t.undefined, t.null, String]),
+})
+
+export const SharedSlice = (sharedSlices: SharedSliceCustomType[]) =>
+	new t.Type<SharedSlice>(
+		"SharedSlice",
+		(u): u is SharedSlice => SharedSliceShape.is(u),
+		(u, c) =>
+			pipe(
+				// We validate the base fields that we can validate directly based on the provided 'sharedSlices'
+				t
+					.type({
+						id: OptionalSharedSliceId,
+						slice_type: SharedSliceType(sharedSlices),
+						slice_label: t.union([t.undefined, t.null, String]),
+						version: t.union([t.undefined, t.null, String]),
+					})
+					.validate(u, c),
+				E.chain((decoded) =>
+					pipe(
+						// We validate the 'variation' field, for which we need the SharedSlice custom type retrieved in the first step
+						t
+							.type({
+								variation: SharedSliceVariation(decoded.slice_type.data),
+							})
+							.validate(u, c),
+						E.map(({ variation }) => ({ ...decoded, variation })),
+					),
+				),
+				E.chain((decoded) =>
+					pipe(
+						// We validate the 'primary' and 'items' content fields, for which we need the Variation custom type retrieved in the previous step
+						t
+							.partial({
+								primary: SharedSliceContent(
+									decoded.slice_type.slice_type,
+									"primary",
+									decoded.variation.data.primary ?? {},
+								),
+								// We need to use this wrapper codec instead of using t.array(SharedSliceContent) directly in order to get proper custom error messages
+								items: AnyArray.pipe(
+									t.array(
+										SharedSliceContent(
+											decoded.slice_type.slice_type,
+											"items",
+											decoded.variation.data.items ?? {},
+										),
+									),
+								),
+							})
+							.validate(u, c),
+						E.map(({ primary, items }) => ({ ...decoded, primary, items })),
+					),
+				),
+				E.map(
+					({
+						id,
+						slice_type,
+						variation,
+						primary,
+						items,
+						slice_label,
+						version,
+					}) => ({
+						id,
+						slice_type: slice_type.slice_type,
+						name: slice_type.data.name,
+						variation: variation.variation,
+						primary,
+						items,
+						slice_label,
+						version: version ?? variation.data.version,
+					}),
+				),
+			),
+		t.identity,
+	)

package/src/import/validators/fields/ImportSlices/SharedSlice/errors.ts

@@ -0,0 +1,6 @@
+export const SharedSliceErrors = {
+	SliceTypeNotFound: (slice_type: string) =>
+		`Shared slice '${slice_type}' not found in document's custom type`,
+	VariationNotFound: (variation: string, slice_type: string) =>
+		`Variation '${variation}' not found for Slice '${slice_type}'`,
+} as const

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/OptionalSharedSliceId.ts

@@ -0,0 +1,20 @@
+import * as t from "io-ts"
+
+import { SharedSliceId } from "./SharedSliceId"
+
+// Wrapping the 'SharedSliceId' codec in an optional codec here for the sake of error reporting.
+// When using t.union([t.undefined, t.null, SharedSliceId]) we get a nested error context
+// with the actual decoding error at position 2 in the context array.
+// To avoid mutating the error context we create this new wrapper codec so that  the error context will always have desired depth.
+export const OptionalSharedSliceId = new t.Type<
+	SharedSliceId | null | undefined
+>(
+	"OptionalSharedSliceId",
+	(u): u is SharedSliceId | null | undefined =>
+		u === null || u === undefined || SharedSliceId.is(u),
+	(u, c) => {
+		if (u === null || u === undefined) return t.success(u)
+		return SharedSliceId.validate(u, c)
+	},
+	t.identity,
+)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContent.ts

@@ -0,0 +1,61 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { WidgetKey } from "../../../../../../../common"
+import type { NestableWidget } from "../../../../../../../customtypes"
+import { combineValidationResults } from "../../../../../../../utils/io-ts"
+import { AnyObject } from "../../../../../../../validators"
+import type { ImportNestable } from "../../../../nestable"
+import { SharedSliceContentEntry } from "./SharedSliceContentEntry"
+
+/**
+ * Represents the object in the 'primary' field or a single item in the 'items' array in the SharedSlice.
+ */
+export type SharedSliceContent = Record<WidgetKey, ImportNestable>
+
+/**
+ * Builds the decoder for a single entry in the 'primary' field or a single item in the 'items' array in the SharedSlice.
+ *
+ * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
+ * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
+ * @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
+ * @constructor
+ */
+export const SharedSliceContent = (
+	sliceName: string,
+	sliceContentField: "primary" | "items",
+	sliceFieldModels: Record<WidgetKey, NestableWidget>,
+) =>
+	new t.Type<SharedSliceContent, SharedSliceContent, unknown>(
+		"SharedSliceContent",
+		(u): u is SharedSliceContent => t.record(WidgetKey, t.unknown).is(u),
+		(u, c) =>
+			pipe(
+				// We first decode the raw content object in the shape of Record<WidgetKey, unknown>
+				AnyObject.validate(u, c),
+				E.chain((rawContent) =>
+					pipe(
+						// We split the object into entries because there is no easy other way to decode each value with a different codec
+						Object.entries(rawContent).map((entry) =>
+							SharedSliceContentEntry(
+								sliceName,
+								sliceContentField,
+								sliceFieldModels,
+							).validate(entry, c),
+						),
+						// We get a validation result for each entry in the content object (t.Validation<SharedSliceContentEntry>[]),
+						// however we want to get a single validation result for the whole array of entries (t.Validation<SharedSliceContentEntry[]>).
+						combineValidationResults,
+						// We build the object back from entries if all decoded successfully
+						E.map((entries) =>
+							entries.reduce(
+								(acc, [key, value]) => ({ ...acc, [key]: value }),
+								{},
+							),
+						),
+					),
+				),
+			),
+		t.identity,
+	)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.ts

@@ -0,0 +1,100 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { WidgetKey } from "../../../../../../../common"
+import type { NestableWidget } from "../../../../../../../customtypes"
+import { ImportNestable } from "../../../../nestable"
+import { SharedSliceContentErrors } from "./errors"
+
+export type SharedSliceContentEntry = [WidgetKey, ImportNestable]
+/**
+ * Represents a single entry in the 'primary' field or a single entry in an item in the 'items' array in the SharedSlice. It is used to build the SharedSliceContent type from entries of the import object.
+ *
+ * For example, given the following slice:
+ * 	{
+ *  	"slice_type": "my_slice",
+ *  	"variation": "default",
+ *      "primary": {
+ *      	"slice_text": "abc", // This is one entry
+ *          "slice_text2": "def: // This is another entry
+ *       },
+ *       "items": [
+ *       	   {
+ *             		"slice_number1": 0, // This is one entry
+ *             		"slice_number2": 1	// And this is yet another entry
+ *             }
+ *       ]
+ *  }
+ *
+ *  The 'primary' object is converted to following entries to be decoded:
+ *  [
+ *      ["slice_text", "abc"],
+ *      ["slice_text2", "def"]
+ *  ]
+ *  and the first item in the 'items' array is converted to following entries to be decoded:
+ *  [
+ *    ["slice_number1", 0],
+ *    ["slice_number2", 1]
+ *  ]
+ *
+ *  We decode them as separate entries because each of the values might require a different codec as per what is specified in the SharedSlice custom type.
+ *  In this way we save on the decoding performance in comparison to a scenario where we would decode the whole content object as a record with a union type decoder for each value.
+ *
+ *  @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
+ *  @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
+ *  @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
+ */
+export const SharedSliceContentEntry = (
+	sliceName: string,
+	sliceContentField: "primary" | "items",
+	sliceFieldModels: Record<WidgetKey, NestableWidget>,
+) =>
+	new t.Type<SharedSliceContentEntry, SharedSliceContentEntry, unknown>(
+		"SharedSliceContentEntry",
+		(u): u is SharedSliceContentEntry =>
+			t.tuple([WidgetKey, t.unknown]).is(u) && ImportNestable.is(u[1]),
+		(u, c) => {
+			return pipe(
+				t.tuple([WidgetKey, t.unknown]).validate(u, c),
+				E.chain(([key, content]) => {
+					const model: NestableWidget | undefined = sliceFieldModels[key]
+					if (!model) {
+						return t.failure(
+							[key, content],
+							[...c, { key, actual: content, type: t.unknown }],
+							SharedSliceContentErrors.UnknownField(
+								sliceName,
+								sliceContentField,
+								key,
+							),
+						)
+					}
+					const { codec, result } = ImportNestable.decode(model)(content)
+
+					return pipe(
+						result,
+						E.map<ImportNestable, SharedSliceContentEntry>((decodedContent) => [
+							key,
+							decodedContent,
+						]),
+						E.mapLeft(
+							(errors): t.Errors =>
+								errors.map((error) => {
+									const context = [
+										...c,
+										...error.context.filter(({ key }) => !!key), // We replace the "" key coming from ImportNestable decoder
+										{ key, actual: content, type: codec },
+									]
+
+									const updatedError: t.ValidationError = { ...error, context }
+
+									return updatedError
+								}),
+						),
+					)
+				}),
+			)
+		},
+		t.identity,
+	)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/errors.ts

@@ -0,0 +1,10 @@
+import type { SharedSliceContentField } from "./types"
+
+export const SharedSliceContentErrors = {
+	UnknownField: (
+		sliceName: string,
+		contentField: SharedSliceContentField,
+		fieldName: string,
+	) =>
+		`Unsupported field '${fieldName}'for '${contentField}' content in Shared Slice '${sliceName}'`,
+} as const

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/index.ts

@@ -0,0 +1,2 @@
+export * from "./errors"
+export * from "./SharedSliceContent"

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/types.ts

@@ -0,0 +1 @@
+export type SharedSliceContentField = "primary" | "items"

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceId.ts

@@ -0,0 +1,65 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { UUID } from "../../../../../../common/UUID"
+import { NonEmptyString } from "../../../../../../validators"
+
+export type SharedSliceId = `${string}$${UUID}`
+
+const baseErrorText =
+	"Slice id must be a non empty string matching the following pattern 'slice_type$uuid'"
+
+export const SharedSliceIdValidationError = {
+	Base: baseErrorText,
+	IncorrectUUID: (uuid: string | undefined) =>
+		`Incorrect UUID: '${uuid}' - ${baseErrorText}`,
+	IncorrectSliceType: (sliceType: string | undefined) =>
+		`Incorrect slice_type: '${sliceType}' - ${baseErrorText}`,
+} as const
+
+export const SharedSliceId = new t.Type<SharedSliceId, string, unknown>(
+	"SharedSliceId",
+	(u): u is SharedSliceId => {
+		if (typeof u !== "string") {
+			return false
+		}
+		const [sliceName, uuid] = u.split("$")
+		return NonEmptyString.is(sliceName) && UUID.is(uuid)
+	},
+	(u, c) =>
+		pipe(
+			NonEmptyString.validate(u, c),
+			E.mapLeft((errors) =>
+				errors.map(
+					(error): t.ValidationError => ({
+						...error,
+						message: SharedSliceIdValidationError.Base,
+					}),
+				),
+			),
+			E.chain((sliceId) => {
+				const [sliceName, uuid] = sliceId.split("$")
+				return pipe(
+					t.tuple([NonEmptyString, UUID]).validate([sliceName, uuid], c),
+					E.mapLeft((errors) =>
+						errors.map((error): t.ValidationError => {
+							const tupleErrorContext = error.context[error.context.length - 1]
+							return {
+								...error,
+								context: [
+									...error.context.slice(0, -1), // We don't want the tuple decoder error context
+								],
+								message:
+									tupleErrorContext?.key === "0"
+										? SharedSliceIdValidationError.IncorrectSliceType(sliceName)
+										: SharedSliceIdValidationError.IncorrectUUID(uuid),
+							}
+						}),
+					),
+				)
+			}),
+			E.map(([sliceName, uuid]) => `${sliceName}$${uuid}`),
+		),
+	(sliceId) => sliceId,
+)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceType.ts

@@ -0,0 +1,45 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { SharedSlice as SharedSliceCustomType } from "../../../../../../customtypes"
+import { NonEmptyString } from "../../../../../../validators"
+import { findSlice } from "../utils"
+
+export type SharedSliceType = {
+	slice_type: string
+	data: SharedSliceCustomType
+}
+
+/**
+ * slice_type - the validated slice_type
+ * slice - SharedSlice custom type data matching the slice_type. We return it alongside the validated slice_type, because it is needed to decode the 'variation' field in the SharedSlice (see SharedSliceVariation.ts)
+ */
+const SharedSliceTypeShape = t.type({
+	slice_type: NonEmptyString,
+	slice: SharedSliceCustomType,
+})
+
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+export const SharedSliceType = (slices: SharedSliceCustomType[]) =>
+	new t.Type<SharedSliceType, string, unknown>(
+		"slice_type",
+		(u): u is SharedSliceType => SharedSliceTypeShape.is(u),
+		(u, c) =>
+			pipe(
+				NonEmptyString.validate(u, c),
+				E.chain((slice_type) =>
+					pipe(
+						findSlice(slices)(slice_type),
+						E.fold(
+							(err) => t.failure(u, c, err),
+							(data) => t.success({ slice_type, data }),
+						),
+					),
+				),
+			),
+		({ slice_type }) => slice_type,
+	)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceVariation.ts

@@ -0,0 +1,45 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { SharedSlice, Variation } from "../../../../../../customtypes"
+import { NonEmptyString } from "../../../../../../validators"
+import { findSliceVariation } from "../utils"
+
+export type SharedSliceVariation = {
+	variation: string
+	data: Variation
+}
+
+/**
+ * variation - the validated variation of the slice
+ * data - Variation data matching the variation. We return it alongside the validated variation, because it is needed to decode the 'primary' and 'items' fields in the SharedSlice.
+ */
+const SharedSliceVariationShape = t.type({
+	variation: NonEmptyString,
+	data: Variation,
+})
+
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+export const SharedSliceVariation = (slice: SharedSlice) =>
+	new t.Type<SharedSliceVariation, string, unknown>(
+		"variation",
+		(u): u is SharedSliceVariation => SharedSliceVariationShape.is(u),
+		(u, c) =>
+			pipe(
+				NonEmptyString.validate(u, c),
+				E.chain((variation) =>
+					pipe(
+						findSliceVariation(slice)(variation),
+						E.fold(
+							(err) => t.failure(u, c, err),
+							(data) => t.success({ variation, data }),
+						),
+					),
+				),
+			),
+		({ variation }) => variation,
+	)

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

@@ -0,0 +1,5 @@
+export * from "./OptionalSharedSliceId"
+export * from "./SharedSliceContent"
+export * from "./SharedSliceId"
+export * from "./SharedSliceType"
+export * from "./SharedSliceVariation"

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

@@ -0,0 +1,3 @@
+export * from "./errors"
+export * from "./fields"
+export * from "./SharedSlice"

package/src/import/validators/fields/ImportSlices/SharedSlice/utils.ts

@@ -0,0 +1,21 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes"
+import type { Variation } from "../../../../../customtypes"
+import { SharedSliceErrors } from "./errors"
+
+export const findSlice =
+	(slices: SharedSliceCustomType[]) => (sliceId: string) =>
+		pipe(
+			slices.find((slice) => slice.id === sliceId),
+			E.fromNullable(SharedSliceErrors.SliceTypeNotFound(sliceId)),
+		)
+
+export const findSliceVariation =
+	(slice: SharedSliceCustomType) =>
+	(variation: string): E.Either<string, Variation> =>
+		pipe(
+			slice.variations.find((v) => v.id === variation),
+			E.fromNullable(SharedSliceErrors.VariationNotFound(variation, slice.id)),
+		)

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

@@ -0,0 +1 @@
+export * from "./ImportSlices"

package/src/import/validators/fields/ImportSlices/utils.ts

@@ -0,0 +1,43 @@
+import * as A from "fp-ts/Array"
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+
+import {
+	SharedSlice as SharedSliceCustomType,
+	StaticSlices,
+} from "../../../../customtypes"
+import type { SharedSlice, SharedSliceId } from "./SharedSlice"
+
+// Extracts all supported slices from the static slices object
+// For now we only support the SharedSlice, if we want to support other slices in the future, we have to add them here
+export const extractSupportedSlices = (
+	staticSlices: StaticSlices,
+): SharedSliceCustomType[] =>
+	pipe(
+		Object.values(staticSlices.config?.choices ?? {}).map((slice) =>
+			pipe(SharedSliceCustomType.decode(slice), O.fromEither),
+		),
+		A.compact,
+	)
+
+export const findImportSharedSliceDuplicateIds = (
+	slices: SharedSlice[],
+): SharedSliceId[] => {
+	const duplicatesMap = slices.reduce((acc, { id }) => {
+		if (id) {
+			const currentNumOfDuplicates = acc[id] ?? 0
+			return {
+				...acc,
+				[id]: acc[id] === undefined ? 0 : currentNumOfDuplicates + 1,
+			}
+		}
+		return acc
+	}, {} as Record<SharedSliceId, number>)
+
+	return Object.entries(duplicatesMap).flatMap(([id, numOfDuplicates]) => {
+		if (numOfDuplicates > 0) {
+			return [id]
+		}
+		return []
+	})
+}

package/src/utils/io-ts.ts

@@ -0,0 +1,29 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as RA from "fp-ts/ReadonlyArray"
+import type { Semigroup } from "fp-ts/Semigroup"
+import type { Errors, Validation } from "io-ts"
+
+/*
+ * Semigroup simply defines how to concatenate two values of the same type.
+ * In this instance, Errors from io-ts are arrays already, so we just need to concatenate them.
+ */
+const validationErrorsSemigroup: Semigroup<Errors> = {
+	concat: (a: Errors, b: Errors) => [...a, ...b],
+}
+
+/*
+ * This is a helper function to combine multiple io-ts validations into one.
+ *  t.array(...) works in the same way - it collects all the errors when decoding an array of values.
+ * 	However, it requires you to pass in a single io-ts validator as a parameter, which is not always convenient.
+ * 	Sometimes we have arrays of validation results received from function calls that don't have a validator instance.
+ */
+export const combineValidationResults = <T>(
+	validationResults: readonly Validation<T>[],
+): Validation<readonly T[]> =>
+	pipe(
+		validationResults,
+		RA.traverse(E.getApplicativeValidation(validationErrorsSemigroup))(
+			(validation) => validation,
+		),
+	)

package/src/validators/BasicTypes.ts

@@ -51,3 +51,8 @@ export const AnyObject = withMessage(
 	t.record(t.string, t.unknown),
 	() => "The value must be an object",
 )
+
+export const AnyArray = withMessage(
+	t.array(t.unknown),
+	() => "The value must be an array",
+)

package/src/validators/NonEmptyString.ts

@@ -1,9 +1,9 @@
 import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
 
 import { refineType } from "./function"
 
-export default refineType(
-	t.string,
-	"nonEmptyString",
-	(s) => s.trim().length > 0,
+export default withMessage(
+	refineType(t.string, "nonEmptyString", (s) => s.trim().length > 0),
+	() => "The value must be a non-empty string",
 )