@prismicio/types-internal 2.2.0-alpha.23 → 2.2.0-alpha.25

package/lib/import/validators/fields/ImportContent.js

@@ -6,12 +6,12 @@ const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const Objects_1 = require("../../../utils/Objects");
-const ImportContent = (type, valueCodec) => new t.Type("ImportField", (u) => {
+const ImportContent = (type, valueCodec) => new t.Type(`ImportField: ${valueCodec.name}`, (u) => {
     if (!(0, Objects_1.isObject)(u))
         return false;
     return type === u["type"] && valueCodec.is(u["value"]);
-}, (u) => {
-    return (0, function_1.pipe)(valueCodec.decode(u), fp_ts_1.either.map((decodedValue) => {
+}, (u, c) => {
+    return (0, function_1.pipe)(valueCodec.validate(u, c), fp_ts_1.either.map((decodedValue) => {
         return {
             type,
             value: decodedValue,

package/lib/import/validators/fields/ImportField.d.ts

@@ -52,7 +52,7 @@ export declare const ImportField: {
         } | undefined, unknown> | import("io-ts").Type<{
             type: "StructuredText";
             value: import("./nestable").ImportBlock[] | null;
-        }, unknown[] | undefined, unknown> | import("io-ts").Type<{
+        }, import("./nestable").ImportBlock[] | undefined, unknown> | import("io-ts").Type<{
             type: "Number";
             value: number | null;
         }, number | undefined, unknown> | import("io-ts").Type<{

package/lib/import/validators/fields/ImportSlices/ImportSlices.js

@@ -13,8 +13,9 @@ const ImportSlices = (staticSlices) => {
     const supportedSlices = (0, utils_1.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((0, SharedSlice_1.SharedSlice)(supportedSlices));
-    return (0, ImportContent_1.ImportContent)("Slices", (0, validators_1.EmptyObjectOrElse)(new t.Type("ImportSlices", (u) => SlicesArrayCodec.is(u), (u, c) => {
+    const SharedSliceCodec = (0, SharedSlice_1.SharedSlice)(supportedSlices);
+    const SlicesArrayCodec = t.array(SharedSliceCodec);
+    return (0, ImportContent_1.ImportContent)("Slices", (0, validators_1.EmptyArrayOrElse)(new t.ArrayType(SlicesArrayCodec.name, (u) => SlicesArrayCodec.is(u), (u, c) => {
         return (0, function_1.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
@@ -24,6 +25,6 @@ const ImportSlices = (staticSlices) => {
             }
             return t.success(slices);
         }));
-    }, t.identity)));
+    }, t.identity, SharedSliceCodec)));
 };
 exports.ImportSlices = ImportSlices;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.js

@@ -58,8 +58,8 @@ const SharedSliceContentEntry = (sliceName, sliceContentField, sliceFieldModels)
         ]), E.mapLeft((errors) => errors.map((error) => {
             const context = [
                 ...c,
-                ...error.context.filter(({ key }) => !!key),
                 { key, actual: content, type: codec },
+                ...error.context.slice(1), // We ignore the first context element with "" key coming from ImportNestable decoder
             ];
             const updatedError = { ...error, context };
             return updatedError;

package/lib/import/validators/fields/nestable/ImportRichText/ImportRichText.d.ts

@@ -20,5 +20,5 @@ export declare const ImportRichText: (customType?: ({
 }) | undefined) => t.Type<{
     type: "StructuredText";
     value: ImportBlock[] | null;
-}, unknown[] | undefined, unknown>;
+}, ImportBlock[] | undefined, unknown>;
 export declare type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>;

package/lib/import/validators/fields/nestable/ImportRichText/ImportRichText.js

@@ -2,25 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportRichText = void 0;
 const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../../../validators");
-const function_1 = require("../../../../../validators/function");
+const function_2 = require("../../../../../validators/function");
 const ImportContent_1 = require("../../ImportContent");
 const ImportBlock_1 = require("./ImportBlock");
-const ImportRichText = (customType) => (0, ImportContent_1.ImportContent)("StructuredText", (0, validators_1.EmptyArrayOrElse)((0, function_1.withCustomError)(t.array(t.unknown).pipe(new t.Type("RichTextField", (u) => t.array((0, ImportBlock_1.ImportBlock)([])).is(u), (u, c) => {
+const ImportRichText = (customType) => {
     var _a, _b, _c, _d;
     const single = (_b = (_a = customType === null || customType === void 0 ? void 0 : customType.config) === null || _a === void 0 ? void 0 : _a.single) === null || _b === void 0 ? void 0 : _b.split(",");
     const multi = (_d = (_c = customType === null || customType === void 0 ? void 0 : customType.config) === null || _c === void 0 ? void 0 : _c.multi) === null || _d === void 0 ? void 0 : _d.split(",");
-    if (multi) {
-        return t.array((0, ImportBlock_1.ImportBlock)(multi)).validate(u, c);
-    }
-    else if (single) {
-        return u.length > 1
-            ? t.failure(u, c, "This field only allows one block")
-            : t.array((0, ImportBlock_1.ImportBlock)(single)).validate(u, c);
-    }
-    else {
-        throw new Error("Rich text config must have either a 'single' or 'multi' field defined");
-    }
-}, t.identity)), () => "Rich text field must be an array")));
+    const allowedBlockTypes = multi || single;
+    const isSingleBlockAllowed = multi === undefined && single !== undefined;
+    const BlockCodec = (0, ImportBlock_1.ImportBlock)(allowedBlockTypes !== null && allowedBlockTypes !== void 0 ? allowedBlockTypes : []);
+    const RichTextArrayCodec = (0, function_2.withCustomError)(t.array(BlockCodec), () => "Rich text field must be an array");
+    return (0, ImportContent_1.ImportContent)("StructuredText", (0, validators_1.EmptyArrayOrElse)(new t.ArrayType(RichTextArrayCodec.name, (u) => RichTextArrayCodec.is(u), (u, c) => {
+        if (allowedBlockTypes === undefined) {
+            throw new Error("Invalid custom type for the rich text field: the model is missing a 'single' or 'multi' field defining a list of allowed block types");
+        }
+        return (0, function_1.pipe)(RichTextArrayCodec.validate(u, c), E.chain((blocks) => {
+            if (isSingleBlockAllowed && blocks.length > 1) {
+                return t.failure(blocks, c, "This field only allows one block");
+            }
+            return t.success(blocks);
+        }));
+    }, t.identity, BlockCodec)));
+};
 exports.ImportRichText = ImportRichText;

package/lib/import/validators/fields/nestable/Nestable.d.ts

@@ -62,7 +62,7 @@ export declare const ImportNestable: {
         } | undefined, unknown> | import("io-ts").Type<{
             type: "StructuredText";
             value: import("./ImportRichText").ImportBlock[] | null;
-        }, unknown[] | undefined, unknown> | import("io-ts").Type<{
+        }, import("./ImportRichText").ImportBlock[] | undefined, unknown> | import("io-ts").Type<{
             type: "Number";
             value: number | null;
         }, number | undefined, unknown> | import("io-ts").Type<{

package/lib/validators/DefaultOrElse.js

@@ -6,10 +6,10 @@ const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const BasicTypes_1 = require("./BasicTypes");
 const DefaultOrElse = (inputValidator) => {
-    return (codec) => new t.Type("DefaultOrElse", (u) => null === u || codec.is(u), (u) => {
-        if ((0, Either_1.isRight)(inputValidator.decode(u)))
+    return (codec) => new t.Type(`DefaultOrElse<${inputValidator.name}, ${codec.name}>`, (u) => null === u || codec.is(u), (u, c) => {
+        if ((0, Either_1.isRight)(inputValidator.validate(u, c)))
             return t.success(null);
-        return codec.decode(u);
+        return codec.validate(u, c);
     }, (chunk) => (chunk ? codec.encode(chunk) : undefined));
 };
 exports.DefaultOrElse = DefaultOrElse;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.23",
+	"version": "2.2.0-alpha.25",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

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

@@ -10,14 +10,14 @@ export const ImportContent = <T extends FieldType, A, O = A>(
 	valueCodec: t.Type<A, O>,
 ) =>
 	new t.Type<{ type: T; value: A }, O>(
-		"ImportField",
+		`ImportField: ${valueCodec.name}`,
 		(u: unknown): u is { type: T; value: A } => {
 			if (!isObject(u)) return false
 			return type === u["type"] && valueCodec.is(u["value"])
 		},
-		(u: unknown) => {
+		(u: unknown, c) => {
 			return pipe(
-				valueCodec.decode(u),
+				valueCodec.validate(u, c),
 				either.map((decodedValue) => {
 					return {
 						type,

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

@@ -3,7 +3,7 @@ import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
 import type { StaticSlices } from "../../../../customtypes"
-import { EmptyObjectOrElse } from "../../../../validators"
+import { EmptyArrayOrElse } from "../../../../validators"
 import { ImportContent } from "../ImportContent"
 import { SharedSlice } from "./SharedSlice"
 import {
@@ -16,13 +16,14 @@ export const ImportSlices = (staticSlices: 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))
+	const SharedSliceCodec = SharedSlice(supportedSlices)
+	const SlicesArrayCodec = t.array(SharedSliceCodec)
 
 	return ImportContent(
 		"Slices",
-		EmptyObjectOrElse(
-			new t.Type<SharedSlice[]>(
-				"ImportSlices",
+		EmptyArrayOrElse(
+			new t.ArrayType<typeof SharedSliceCodec, SharedSlice[]>(
+				SlicesArrayCodec.name,
 				(u): u is SharedSlice[] => SlicesArrayCodec.is(u),
 				(u, c) => {
 					return pipe(
@@ -46,6 +47,7 @@ export const ImportSlices = (staticSlices: StaticSlices) => {
 					)
 				},
 				t.identity,
+				SharedSliceCodec,
 			),
 		),
 	)

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

@@ -83,8 +83,8 @@ export const SharedSliceContentEntry = (
 								errors.map((error) => {
 									const context = [
 										...c,
-										...error.context.filter(({ key }) => !!key), // We replace the "" key coming from ImportNestable decoder
 										{ key, actual: content, type: codec },
+										...error.context.slice(1), // We ignore the first context element with "" key coming from ImportNestable decoder
 									]
 
 									const updatedError: t.ValidationError = { ...error, context }

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

@@ -1,3 +1,5 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
 import type { RichText as RichTextCustomType } from "../../../../../customtypes"
@@ -6,36 +8,47 @@ import { withCustomError } from "../../../../../validators/function"
 import { ImportContent } from "../../ImportContent"
 import { ImportBlock } from "./ImportBlock"
 
-export const ImportRichText = (customType?: RichTextCustomType) =>
-	ImportContent(
+export const ImportRichText = (customType?: RichTextCustomType) => {
+	const single = customType?.config?.single?.split(",")
+	const multi = customType?.config?.multi?.split(",")
+	const allowedBlockTypes = multi || single
+
+	const isSingleBlockAllowed = multi === undefined && single !== undefined
+
+	const BlockCodec = ImportBlock(allowedBlockTypes ?? [])
+	const RichTextArrayCodec = withCustomError(
+		t.array(BlockCodec),
+		() => "Rich text field must be an array",
+	)
+
+	return ImportContent(
 		"StructuredText",
 		EmptyArrayOrElse(
-			withCustomError(
-				t.array(t.unknown).pipe(
-					new t.Type<ImportBlock[], ImportBlock[], unknown[]>(
-						"RichTextField",
-						(u): u is ImportBlock[] => t.array(ImportBlock([])).is(u),
-						(u, c) => {
-							const single = customType?.config?.single?.split(",")
-							const multi = customType?.config?.multi?.split(",")
+			new t.ArrayType<typeof BlockCodec, ImportBlock[], ImportBlock[]>(
+				RichTextArrayCodec.name,
+				(u): u is ImportBlock[] => RichTextArrayCodec.is(u),
+				(u, c) => {
+					if (allowedBlockTypes === undefined) {
+						throw new Error(
+							"Invalid custom type for the rich text field: the model is missing a 'single' or 'multi' field defining a list of allowed block types",
+						)
+					}
 
-							if (multi) {
-								return t.array(ImportBlock(multi)).validate(u, c)
-							} else if (single) {
-								return u.length > 1
-									? t.failure(u, c, "This field only allows one block")
-									: t.array(ImportBlock(single)).validate(u, c)
-							} else {
-								throw new Error(
-									"Rich text config must have either a 'single' or 'multi' field defined",
-								)
+					return pipe(
+						RichTextArrayCodec.validate(u, c),
+						E.chain((blocks) => {
+							if (isSingleBlockAllowed && blocks.length > 1) {
+								return t.failure(blocks, c, "This field only allows one block")
 							}
-						},
-						t.identity,
-					),
-				),
-				() => "Rich text field must be an array",
+							return t.success(blocks)
+						}),
+					)
+				},
+				t.identity,
+				BlockCodec,
 			),
 		),
 	)
+}
+
 export type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>

package/src/validators/DefaultOrElse.ts

@@ -6,11 +6,11 @@ import { EmptyArray, EmptyObject } from "./BasicTypes"
 export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
 	return (codec: t.Type<A, O>) =>
 		new t.Type<A | null, O | undefined>(
-			"DefaultOrElse",
+			`DefaultOrElse<${inputValidator.name}, ${codec.name}>`,
 			(u: unknown): u is A | null => null === u || codec.is(u),
-			(u: unknown) => {
-				if (isRight(inputValidator.decode(u))) return t.success(null)
-				return codec.decode(u)
+			(u: unknown, c) => {
+				if (isRight(inputValidator.validate(u, c))) return t.success(null)
+				return codec.validate(u, c)
 			},
 			(chunk) => (chunk ? codec.encode(chunk) : undefined),
 		)