@prismicio/types-internal 2.2.1-alpha.0 → 2.2.1-remove-import.alpha-1

package/src/import/validators/Document.ts

@@ -1,103 +0,0 @@
-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 type { WidgetKey } from "../../common"
-import type { StaticCustomType, StaticWidget } from "../../customtypes"
-import { flattenCustomTypeFields } from "../../customtypes"
-import { isObject } from "../../utils/Objects"
-import { withCustomError } from "../../validators/function"
-import { ImportField } from "./fields/ImportField"
-
-const rawImportDocument = withCustomError(
-	t.UnknownRecord,
-	() => "document is not an object",
-)
-
-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])
-		}
-
-		// retrieving the right codec then testing out fieldValue with it.
-		const { result, codec } = ImportField.decode(model)(content)
-
-		// 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),
-				]
-
-				return { ...error, context }
-			})
-			return either.left(errors)
-		}
-		return either.right(result.right)
-	}
-}
-
-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],
-			)
-
-			if (isLeft(parsedField))
-				return { ...acc, errors: [...acc.errors, ...parsedField.left] }
-
-			return {
-				...acc,
-				document: { ...acc.document, [fieldKey]: parsedField.right },
-			}
-		},
-		{ document: {}, errors: [] },
-	)
-	if (errors.length > 0) return either.left(errors)
-	return either.right(document)
-}
-
-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)),
-			)
-		},
-		t.identity,
-	)

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

@@ -1,30 +0,0 @@
-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: ${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, c) => {
-			return pipe(
-				valueCodec.validate(u, c),
-				either.map((decodedValue) => {
-					return {
-						type,
-						value: decodedValue,
-					}
-				}),
-			)
-		},
-		(field) => field.value as unknown as O,
-	)

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

@@ -1,36 +0,0 @@
-import type { StaticWidget } from "../../../customtypes"
-import { ImportGroup } from "./ImportGroup"
-import { ImportSlices } from "./ImportSlices"
-import { ImportNestable } from "./nestable"
-
-export type ImportField = ImportSlices | ImportNestable | ImportGroup
-
-export const ImportField = {
-	is(u: unknown): u is ImportField {
-		return ImportField.is(u)
-	},
-	decode: (field: StaticWidget) => {
-		return (content: unknown) => {
-			switch (field.type) {
-				case "UID":
-					throw new Error(
-						`The field '${field.type}' should be put at the root level of the document`,
-					)
-				case "Slices":
-					return {
-						codec: ImportSlices(field),
-						result: ImportSlices(field).decode(content),
-					}
-				case "Group":
-					return {
-						codec: ImportGroup(field),
-						result: ImportGroup(field).decode(content),
-					}
-				case "Choice":
-					throw new Error(`Unsupported type of field ${field.type}`)
-				default:
-					return ImportNestable.decode(field)(content)
-			}
-		}
-	},
-}

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

@@ -1,45 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import type { Group } from "../../../customtypes"
-import { EmptyArrayOrElse } from "../../../validators"
-import { withCustomError } from "../../../validators/function"
-import { ImportContent } from "./ImportContent"
-import { RepeatableZone } from "./RepeatableZone"
-
-export const ImportGroupValue = (groupCustomType?: Group) => {
-	const fieldsModel = groupCustomType?.config?.fields ?? {}
-	const groupArrayCodec = RepeatableZone(fieldsModel)
-
-	return withCustomError(
-		new t.Type<RepeatableZone>(
-			groupArrayCodec.name,
-			groupArrayCodec.is,
-			(u, c) =>
-				pipe(
-					groupArrayCodec.validate(u, c),
-					E.chain((groups) => {
-						if (
-							groupCustomType?.config?.repeat === false &&
-							groups.length > 1
-						) {
-							return t.failure(
-								groups,
-								c,
-								"The custom type for this group field does not allow multiple group items",
-							)
-						}
-						return t.success(groups)
-					}),
-				),
-			t.identity,
-		),
-		() => "The group field value must be an array",
-	)
-}
-
-export const ImportGroup = (groupCustomType?: Group) =>
-	ImportContent("Group", EmptyArrayOrElse(ImportGroupValue(groupCustomType)))
-
-export type ImportGroup = t.TypeOf<ReturnType<typeof ImportGroup>>

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

@@ -1,56 +0,0 @@
-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 { EmptyArrayOrElse } 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 SharedSliceCodec = SharedSlice(supportedSlices)
-	const SlicesArrayCodec = t.array(SharedSliceCodec)
-
-	return ImportContent(
-		"Slices",
-		EmptyArrayOrElse(
-			new t.ArrayType<typeof SharedSliceCodec, SharedSlice[]>(
-				SlicesArrayCodec.name,
-				(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,
-				SharedSliceCodec,
-			),
-		),
-	)
-}
-
-export type ImportSlices = t.TypeOf<ReturnType<typeof ImportSlices>>

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

@@ -1,104 +0,0 @@
-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 { NonEmptyString, String } from "../../../../../validators"
-import { RepeatableZone } from "../../RepeatableZone"
-import { RepeatableZoneItem } from "../../RepeatableZoneItem"
-import {
-	OptionalSharedSliceId,
-	SharedSliceId,
-	SharedSliceType,
-	SharedSliceVariation,
-} from "./fields"
-
-export type SharedSlice = {
-	id: SharedSliceId | null | undefined
-	slice_type: string
-	name: string
-	variation: string
-	primary: RepeatableZoneItem | null | undefined
-	items: RepeatableZone | null | undefined
-	slice_label: string | null | undefined
-	version: string | null | undefined
-}
-
-const SharedSliceShape = t.strict({
-	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: RepeatableZoneItem(
-									decoded.variation.data.primary ?? {},
-								),
-								items: RepeatableZone(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

@@ -1,6 +0,0 @@
-export const SharedSliceErrors = {
-	SliceTypeNotFound: (slice_type: string) =>
-		`Shared slice '${slice_type}' not found in this slice zone in the 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

@@ -1,20 +0,0 @@
-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/SharedSliceId.ts

@@ -1,65 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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.strict({
-	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

@@ -1,45 +0,0 @@
-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.strict({
-	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

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

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

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

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

@@ -1,21 +0,0 @@
-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

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

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

@@ -1,43 +0,0 @@
-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/import/validators/fields/RepeatableZone.ts

@@ -1,21 +0,0 @@
-import * as t from "io-ts"
-
-import type { WidgetKey } from "../../../common"
-import type { NestableWidget } from "../../../customtypes"
-import { withCustomError } from "../../../validators/function"
-import { RepeatableZoneItem } from "./RepeatableZoneItem"
-
-export type RepeatableZone = t.TypeOf<ReturnType<typeof RepeatableZone>>
-
-/**
- * A custom type for a repeatable zone. This type of structure can be found 'items' field of a slice or in the group field.
- *
- * @param fieldModels a record of all nestable widgets that can be used in the zone
- */
-export const RepeatableZone = (
-	fieldModels: Record<WidgetKey, NestableWidget>,
-) =>
-	withCustomError(
-		t.array(RepeatableZoneItem(fieldModels)),
-		() => "The repeatable zone value must be an array",
-	)