@prismicio/types-internal 2.1.0-alpha.4 → 2.2.0-alpha.0

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

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

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

@@ -0,0 +1,7 @@
+export * from "./Color"
+export * from "./Date"
+export * from "./Nestable"
+export * from "./Number"
+export * from "./Select"
+export * from "./Text"
+export * from "./Timestamp"

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

@@ -0,0 +1,7 @@
+export const nullableConverter = <I, O>(
+	value: I | null,
+	converter: (value: I) => O,
+): O | undefined => {
+	if (value === null) return undefined
+	else return converter(value)
+}

package/src/import/converters/index.ts

@@ -0,0 +1,2 @@
+export * from "./Document"
+export * from "./fields"

package/src/import/index.ts

@@ -0,0 +1,2 @@
+export * from "./converters"
+export * from "./validators"

package/src/import/validators/Document.ts

@@ -0,0 +1,79 @@
+import * as Either from "fp-ts/Either"
+import * as t from "io-ts"
+
+import type { WidgetKey } from "../../common"
+import {
+	isNestableWidget,
+	StaticCustomType,
+	StaticWidget,
+} from "../../customtypes"
+import { isObject } from "../../utils/Objects"
+import { getNestableFieldCodec, ImportNestable } from "./fields"
+
+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])
+			}
+
+			// flattening the fields within the tabs
+			const maskFields = Object.values(mask.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]
+
+					// 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 fieldCodec = getFieldCodec(maskFieldValue)
+					const result = fieldCodec.decode(fieldValue)
+
+					// returning validation errors
+					if (Either.isLeft(result))
+						return { ...acc, errors: [...acc.errors, ...result.left] }
+
+					// registering the field as validated
+					return {
+						...acc,
+						document: { ...acc.document, [fieldKey]: result.right },
+					}
+				},
+				{ document: {}, errors: [] },
+			)
+
+			// 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/index.ts

@@ -0,0 +1,8 @@
+import type { FieldType } from "../../../customtypes"
+
+export * from "./nestable"
+
+export interface ImportFieldOutput<t extends FieldType, v, d = null> {
+	type: t
+	value: v | d
+}

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

@@ -0,0 +1,28 @@
+import * as t from "io-ts"
+
+import { HexaColor, HexaColorCode } from "../../../../common/HexaColorCode"
+import { NullOrT, String } from "../../../../validators"
+import type { ImportFieldOutput } from ".."
+
+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",
+					)
+				}
+
+				return t.success(s)
+			},
+			t.identity,
+		),
+	),
+)((s: HexaColorCode | null) => ({ type: "Color", value: s }))

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

@@ -0,0 +1,35 @@
+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 ".."
+
+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())
+
+					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,
+	),
+)((s: Date | null) => ({ type: "Date", value: s }))

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

@@ -0,0 +1,41 @@
+import type { NestableWidget } from "../../../../customtypes"
+import { ImportDate, ImportTimestamp } from "."
+import { ImportColor } from "./Color"
+import { ImportNumber } from "./Number"
+import { ImportSelect } from "./Select"
+import { ImportText } from "./Text"
+
+export type ImportNestable =
+	| ImportColor
+	| ImportSelect
+	| ImportNumber
+	| ImportText
+	| ImportDate
+	| ImportTimestamp
+
+export const isNestableFieldValue = (u: unknown): u is ImportNestable =>
+	ImportColor.is(u) ||
+	ImportSelect().is(u) ||
+	ImportNumber().is(u) ||
+	ImportText.is(u) ||
+	ImportDate.is(u) ||
+	ImportTimestamp.is(u)
+
+export function getNestableFieldCodec(field: NestableWidget) {
+	switch (field.type) {
+		case "Color":
+			return ImportColor
+		case "Select":
+			return ImportSelect(field.config)
+		case "Number":
+			return ImportNumber(field.config)
+		case "Text":
+			return ImportText
+		case "Date":
+			return ImportDate
+		case "Timestamp":
+			return ImportTimestamp
+		default:
+			throw new Error(`Unsupported type of nestable field ${field.type}`)
+	}
+}

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

@@ -0,0 +1,36 @@
+import * as t from "io-ts"
+
+import type { NumberConfig } from "../../../../customtypes"
+import { NullOrT, Number } from "../../../../validators"
+import type { ImportFieldOutput } from ".."
+
+export type ImportNumber = ImportFieldOutput<"Number", number>
+export const ImportNumber = (config?: NumberConfig) =>
+	NullOrT<number, ImportNumber>(
+		Number.pipe(
+			new t.Type<number, number, number>(
+				"ImportColorField",
+				(u: unknown): u is number => Number.is(u),
+				(n: number, c: t.Context) => {
+					const min = config?.min
+					const max = config?.max
+
+					if (
+						(min !== undefined && n < min) ||
+						(max !== undefined && n > max)
+					) {
+						return t.failure(
+							n,
+							c,
+							`The value must be between [${min !== undefined ? min : ""}, ${
+								max !== undefined ? max : ""
+							}]`,
+						)
+					}
+
+					return t.success(n)
+				},
+				t.identity,
+			),
+		),
+	)((n: number | null) => ({ type: "Number", value: n }))

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

@@ -0,0 +1,36 @@
+import * as t from "io-ts"
+
+import type { SelectConfig } from "../../../../customtypes"
+import { NullOrT, String } from "../../../../validators"
+import type { ImportFieldOutput } from ".."
+
+export type ImportSelect = ImportFieldOutput<"Select", string>
+export const ImportSelect = (config?: SelectConfig) =>
+	NullOrT<string, ImportSelect>(
+		String.pipe(
+			new t.Type<string, string, string>(
+				"ImportColorField",
+				(u: unknown): u is string => String.is(u),
+				(s: string, c: t.Context) => {
+					if (!config?.options) {
+						return t.failure(
+							s,
+							c,
+							"The value must be defined in the custom type's configuration of the field",
+						)
+					}
+
+					if (!config.options.includes(s)) {
+						return t.failure(
+							s,
+							c,
+							`The value must be one of these: ${config.options?.join(",")}`,
+						)
+					}
+
+					return t.success(s)
+				},
+				t.identity,
+			),
+		),
+	)((s: string | null) => ({ type: "Select", value: s }))

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

@@ -0,0 +1,7 @@
+import { NullOrT, String } from "../../../../validators"
+import type { ImportFieldOutput } from ".."
+
+export type ImportText = ImportFieldOutput<"Text", string>
+export const ImportText = NullOrT<string, ImportText>(String)(
+	(s: string | null) => ({ type: "Text", value: s }),
+)

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

@@ -0,0 +1,36 @@
+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 ".."
+
+export const TIMESTAMP_INPUT_REGEX =
+	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:(?:[+-]{1}\d{2}:?\d{2})|Z)$/
+
+export type ImportTimestamp = ImportFieldOutput<"Timestamp", Date>
+export const ImportTimestamp = NullOrT<Date, ImportTimestamp>(
+	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())
+
+					if (isInvalidDate || !TIMESTAMP_INPUT_REGEX.test(s)) {
+						return t.failure(
+							u,
+							c,
+							"The value must be a DateTime in the format YYYY-MM-DDTHH:MM:SS+0000",
+						)
+					}
+
+					return t.success(date)
+				}),
+			),
+		t.identity,
+	),
+)((s: Date | null) => ({ type: "Timestamp", value: s }))

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

@@ -0,0 +1,7 @@
+export * from "./Color"
+export * from "./Date"
+export * from "./Nestable"
+export * from "./Number"
+export * from "./Select"
+export * from "./Text"
+export * from "./Timestamp"

package/src/import/validators/index.ts

@@ -0,0 +1,2 @@
+export * from "./Document"
+export * from "./fields"

package/src/utils/Objects.ts

@@ -1,3 +1,6 @@
+import { isRight } from "fp-ts/lib/Either"
+import * as t from "io-ts"
+
 export function zipObjects<A, B = A>(
 	objLeft?: Partial<Record<string, A>> | undefined,
 	objRight?: Partial<Record<string, B>> | undefined,
@@ -33,3 +36,8 @@ export function withOptionals<T extends object>(
 		}, {}),
 	}
 }
+
+const recordCodec = t.record(t.string, t.unknown)
+export function isObject(value: unknown): value is Record<string, unknown> {
+	return isRight(recordCodec.decode(value))
+}

package/src/utils/index.ts

@@ -1,2 +1,3 @@
+export * as HexaColorCode from "../common/HexaColorCode"
 export * as Arrays from "./Arrays"
 export * as Objects from "./Objects"

package/src/validators/BasicTypes.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
+
+export const String = withMessage(t.string, () => "The value must be a string")
+export const Number = withMessage(t.number, () => "The value must be a number")

package/src/validators/DateFromString.ts

@@ -2,12 +2,14 @@ import { chain } from "fp-ts/Either"
 import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
+import { String } from "."
+
 export default new t.Type<Date, string, unknown>(
 	"dateFromString",
 	(u): u is Date => u instanceof Date,
 	(u, c) =>
 		pipe(
-			t.string.validate(u, c),
+			String.validate(u, c),
 			chain((s) => {
 				const d = new Date(s)
 				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)

package/src/validators/NullOrT.ts

@@ -0,0 +1,18 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+export const NullOrT = <T, O = T>(codec: t.Type<T>) => {
+	return (asO: (value: T | null) => O) =>
+		new t.Type<O>(
+			`NullOr${codec.name}`,
+			(u: unknown): u is O => t.null.is(u) || codec.is(u),
+			(u: unknown) => {
+				return pipe(
+					t.union([t.null, codec]).decode(u),
+					either.map((decoded) => asO(decoded)),
+				)
+			},
+			(f) => f,
+		)
+}

package/src/validators/index.ts

@@ -1,3 +1,4 @@
+export * from "./BasicTypes"
 export { default as DateFromString } from "./DateFromString"
 export { default as DateFromStringOrNumber } from "./DateFromStringOrNumber"
 export { default as DateFromTsMs } from "./DateFromTsMs"
@@ -6,6 +7,7 @@ export { default as IntFromNumber } from "./IntFromNumber"
 export { default as IntFromPixels } from "./IntFromPixels"
 export { default as NonEmptyString } from "./NonEmptyString"
 export { default as NonEmptyStringOrNull } from "./NonEmptyStringOrNull"
+export * from "./NullOrT"
 export { default as NumberOrNull } from "./NumberOrNull"
 export { default as StringFromBoolean } from "./StringFromBoolean"
 export { default as StringFromNumber } from "./StringFromNumber"

package/lib/customtypes/_internal/utils.d.ts

@@ -1,3 +0,0 @@
-import type { DynamicSlice, DynamicWidget } from "../widgets";
-export declare type TraverseFn = <T extends DynamicWidget | DynamicSlice>(widget: T, key: string, path: ReadonlyArray<string>) => DynamicWidget | DynamicSlice | undefined;
-export declare function fromEntriesWithValue<T>(entries: (string | T)[][]): {};

package/lib/customtypes/_internal/utils.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromEntriesWithValue = void 0;
-function fromEntriesWithValue(entries) {
-    return Array.from(entries).reduce((acc, entry) => {
-        /**
-         * Replace the untyped default `fromEntries`
-         * Role: filter pair with undefined value
-         * Error: Throw an error if malformed: key[string]/value[T]
-         */
-        if (entry.length !== 2 || typeof entry[0] !== "string")
-            throw new Error("Malformed entry, should be a key[string]/value[T] pair.");
-        const [key, value] = entry;
-        if (value !== undefined) {
-            return { ...acc, [key]: entry[1] };
-        }
-        return acc;
-    }, {});
-}
-exports.fromEntriesWithValue = fromEntriesWithValue;

package/lib/customtypes/widgets/nestable/Link/ContentRelationshipResolver.d.ts

@@ -1,11 +0,0 @@
-import * as t from "io-ts";
-export declare const ContentRelationshipResolver: t.ReadonlyArrayC<t.Type<{
-    customTypeId: string;
-} & {
-    fetchFields?: boolean;
-}, {
-    customTypeId: string;
-} & {
-    fetchFields?: boolean;
-}, unknown>>;
-export declare type ContentRelationshipResolver = t.TypeOf<typeof ContentRelationshipResolver>;

package/lib/customtypes/widgets/nestable/Link/ContentRelationshipResolver.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContentRelationshipResolver = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const StringOrT_1 = (0, tslib_1.__importDefault)(require("../../../../validators/StringOrT"));
-const CustomTypeResolver = (0, StringOrT_1.default)(t.intersection([
-    t.type({
-        customTypeId: t.string,
-    }),
-    t.partial({
-        fetchFields: t.boolean,
-    }),
-]))((id) => ({ customTypeId: id }));
-exports.ContentRelationshipResolver = t.readonlyArray(CustomTypeResolver);

package/lib/validators/StringOrT.d.ts

@@ -1,3 +0,0 @@
-import * as t from "io-ts";
-declare const _default: <T>(codec: t.Type<T, T, unknown>) => (asObject: (strValue: string) => T) => t.Type<T, T, unknown>;
-export default _default;

package/lib/validators/StringOrT.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const fp_ts_1 = require("fp-ts");
-const function_1 = require("fp-ts/function");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-exports.default = (codec) => {
-    return (asObject) => new t.Type("StringOrT", (u) => u instanceof Object, (u) => {
-        return (0, function_1.pipe)(t.union([t.string, codec]).decode(u), fp_ts_1.either.map((decoded) => {
-            if (typeof decoded === "string")
-                return asObject(decoded);
-            return decoded;
-        }));
-    }, (f) => f);
-};

package/src/customtypes/_internal/utils.ts

@@ -1,25 +0,0 @@
-import type { DynamicSlice, DynamicWidget } from "../widgets"
-
-export type TraverseFn = <T extends DynamicWidget | DynamicSlice>(
-	widget: T,
-	key: string,
-	path: ReadonlyArray<string>,
-) => DynamicWidget | DynamicSlice | undefined
-
-export function fromEntriesWithValue<T>(entries: (string | T)[][]) {
-	return Array.from(entries).reduce((acc, entry) => {
-		/**
-		 * Replace the untyped default `fromEntries`
-		 * Role: filter pair with undefined value
-		 * Error: Throw an error if malformed: key[string]/value[T]
-		 */
-		if (entry.length !== 2 || typeof entry[0] !== "string")
-			throw new Error("Malformed entry, should be a key[string]/value[T] pair.")
-
-		const [key, value] = entry
-		if (value !== undefined) {
-			return { ...acc, [key]: entry[1] }
-		}
-		return acc
-	}, {})
-}

package/src/customtypes/widgets/nestable/Link/ContentRelationshipResolver.ts

@@ -1,20 +0,0 @@
-import * as t from "io-ts"
-
-import StringOrT from "../../../../validators/StringOrT"
-
-const CustomTypeResolver = StringOrT(
-	t.intersection([
-		t.type({
-			customTypeId: t.string,
-		}),
-		t.partial({
-			fetchFields: t.boolean,
-		}),
-	]),
-)((id) => ({ customTypeId: id }))
-type CustomTypeResolver = t.TypeOf<typeof CustomTypeResolver>
-
-export const ContentRelationshipResolver = t.readonlyArray(CustomTypeResolver)
-export type ContentRelationshipResolver = t.TypeOf<
-	typeof ContentRelationshipResolver
->

package/src/validators/StringOrT.ts

@@ -1,21 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export default <T>(codec: t.Type<T>) => {
-	return (asObject: (strValue: string) => T) =>
-		new t.Type<T>(
-			"StringOrT",
-			(u: unknown): u is T => u instanceof Object,
-			(u: unknown) => {
-				return pipe(
-					t.union([t.string, codec]).decode(u),
-					either.map((decoded) => {
-						if (typeof decoded === "string") return asObject(decoded)
-						return decoded
-					}),
-				)
-			},
-			(f) => f,
-		)
-}