@prismicio/types-internal 2.2.0-alpha.9 → 2.2.0-traverse.alpha-1

package/src/content/fields/GroupContent.ts

@@ -3,6 +3,8 @@ import { isLeft } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
+import type { ContentPath, TraverseContentFn } from "../../_internal/utils"
+import type { Group, NestableWidget } from "../../customtypes"
 import {
 	FieldOrSliceType,
 	getFieldCtx,
@@ -117,3 +119,69 @@ export const GroupContent = t.strict({
 	value: t.array(GroupItemContent),
 })
 export type GroupContent = t.TypeOf<typeof GroupContent>
+
+export function traverseGroupContent({
+	path,
+	model,
+	content,
+}: {
+	path: ContentPath
+	content: GroupContent
+	model?: Group | undefined
+}) {
+	return (transform: TraverseContentFn): GroupContent => {
+		const groupItems = traverseGroupItemsContent({
+			path,
+			model: model?.config?.fields,
+			content: content.value,
+		})(transform)
+
+		return {
+			__TYPE__: content.__TYPE__,
+			value: groupItems,
+		}
+	}
+}
+
+export function traverseGroupItemsContent({
+	path,
+	model,
+	content,
+}: {
+	path: ContentPath
+	content: Array<GroupItemContent>
+	model?: Record<string, NestableWidget> | undefined
+}) {
+	return (transform: TraverseContentFn): Array<GroupItemContent> => {
+		return content.map((groupItem, index) => {
+			const groupItemPath = path.concat([
+				{ key: index.toString(), type: "GroupItem" },
+			])
+
+			const groupItemFields = groupItem.value.reduce<GroupItemContent["value"]>(
+				(acc, [fieldKey, fieldContent]) => {
+					const fieldDef = model?.[fieldKey]
+
+					const transformedField = transform({
+						path: groupItemPath.concat([
+							{ key: fieldKey, type: fieldContent.__TYPE__ },
+						]),
+						key: fieldKey,
+						apiId: fieldKey,
+						model: fieldDef,
+						content: fieldContent,
+					})
+					// Can happen if the transform function returns undefined to filter out a field
+					if (!transformedField) return acc
+					return acc.concat([[fieldKey, transformedField]])
+				},
+				[],
+			)
+
+			return {
+				__TYPE__: groupItem.__TYPE__,
+				value: groupItemFields,
+			}
+		})
+	}
+}

package/src/content/fields/nestable/NestableContent.ts

@@ -1,6 +1,7 @@
 import { isRight } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
+import type { NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx } from "../../LegacyContentCtx"
 import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
 import {
@@ -200,3 +201,34 @@ export const NestableLegacy = (ctx: LegacyContentCtx) => {
 		},
 	}
 }
+
+export function isValidStaticNestableContent(
+	content: NestableContent,
+	model?: NestableWidget,
+) {
+	if (!model) return false
+
+	switch (content.__TYPE__) {
+		// special case for no content so we can consider it valid no matter its model
+		case "EmptyContent":
+			return true
+		case "BooleanContent":
+			return model.type === "Boolean"
+		case "EmbedContent":
+			return model.type === "Embed"
+		case "FieldContent":
+			return content.type === model.type
+		case "GeoPointContent":
+			return model.type === "GeoPoint"
+		case "ImageContent":
+			return model.type === "Image"
+		case "IntegrationFieldsContent":
+			return model.type === "IntegrationFields"
+		case "LinkContent":
+			return model.type === "Link"
+		case "StructuredTextContent":
+			return model.type === "StructuredText"
+		case "SeparatorContent":
+			return model.type === "Separator"
+	}
+}

package/src/content/fields/slices/Slice/CompositeSliceContent.ts

@@ -3,12 +3,18 @@ import { isLeft } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
+import type {
+	ContentPath,
+	TraverseContentFn,
+} from "../../../../_internal/utils"
+import type { CompositeSlice } from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
+import { traverseGroupItemsContent } from "../../GroupContent"
 import { NestableContent, NestableLegacy } from "../../nestable"
 import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
@@ -117,3 +123,52 @@ export const CompositeSliceContent = t.strict({
 })
 
 export type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>
+
+export function traverseCompositeSliceContent({
+	path,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceName: string
+	content: CompositeSliceContent
+	model?: CompositeSlice | undefined
+}) {
+	return (transform: TraverseContentFn): CompositeSliceContent => {
+		const primary = Object.entries(content.nonRepeat).reduce<
+			Record<string, NestableContent>
+		>((acc, [fieldKey, fieldContent]) => {
+			const fieldDef = model?.["non-repeat"]?.[fieldKey]
+
+			const transformedField = transform({
+				path: path.concat([
+					{ key: "non-repeat", type: "primary" },
+					{ key: fieldKey, type: fieldContent.__TYPE__ },
+				]),
+				key: fieldKey,
+				apiId: sliceName,
+				model: fieldDef,
+				content: fieldContent,
+			})
+			// Can happen if the transform function returns undefined to filter out a field
+			if (!transformedField) return acc
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
+
+		const items = traverseGroupItemsContent({
+			path: path.concat([{ key: "repeat", type: "items" }]),
+			model: model?.repeat,
+			content: content.repeat,
+		})(transform)
+
+		return {
+			__TYPE__: content.__TYPE__,
+			repeat: items,
+			nonRepeat: primary,
+		}
+	}
+}

package/src/content/fields/slices/Slice/RepeatableContent.ts

@@ -13,6 +13,5 @@ const RepeatableWidgetsBlock = t.strict({
 	__TYPE__: t.literal(GroupItemContentType),
 	value: t.array(RepeatableWidget),
 })
-t.array(RepeatableWidget)
 
 export const RepeatableWidgets = t.array(RepeatableWidgetsBlock)

package/src/content/fields/slices/Slice/SharedSliceContent.ts

@@ -4,12 +4,18 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types"
 
+import type {
+	ContentPath,
+	TraverseContentFn,
+} from "../../../../_internal/utils"
+import type { SharedSlice } from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
+import { traverseGroupItemsContent } from "../../GroupContent"
 import { NestableContent, NestableLegacy } from "../../nestable"
 import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
@@ -128,3 +134,57 @@ export const SharedSliceContent = t.strict({
 	items: RepeatableWidgets,
 })
 export type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>
+
+export function traverseSharedSliceContent({
+	path,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceName: string
+	content: SharedSliceContent
+	model?: SharedSlice | undefined
+}) {
+	return (transform: TraverseContentFn): SharedSliceContent => {
+		const variationDef = model?.variations.find(
+			(v) => v.id === content.variation,
+		)
+
+		const primary = Object.entries(content.primary).reduce<
+			Record<string, NestableContent>
+		>((acc, [fieldKey, fieldContent]) => {
+			const fieldDef = variationDef && variationDef.primary?.[fieldKey]
+
+			const transformedField = transform({
+				path: path.concat([
+					{ key: "primary", type: "primary" },
+					{ key: fieldKey, type: fieldContent.__TYPE__ },
+				]),
+				key: fieldKey,
+				apiId: sliceName,
+				model: fieldDef,
+				content: fieldContent,
+			})
+			// Can happen if the transform function returns undefined to filter out a field
+			if (!transformedField) return acc
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
+
+		const items = traverseGroupItemsContent({
+			path: path.concat([{ key: "items", type: "items" }]),
+			model: variationDef?.items,
+			content: content.items,
+		})(transform)
+
+		return {
+			__TYPE__: content.__TYPE__,
+			variation: content.variation,
+			primary,
+			items,
+		}
+	}
+}

package/src/content/fields/slices/SlicesContent.ts

@@ -2,12 +2,23 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
+import type { ContentPath, TraverseContentFn } from "../../../_internal/utils"
+import {
+	type StaticSlice,
+	type StaticSlices,
+	isCompositeSlice,
+	isLegacySlice,
+	isStaticSharedSlice,
+} from "../../../customtypes"
 import type {
 	FieldOrSliceType,
 	LegacyContentCtx,
 	WithTypes,
 } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
+import { traverseGroupContent } from "../GroupContent"
+import { traverseCompositeSliceContent } from "./Slice/CompositeSliceContent"
+import { traverseSharedSliceContent } from "./Slice/SharedSliceContent"
 import { SliceItemContent, SlicesItemLegacy } from "./SliceItem"
 
 export const SlicesContentType = "SliceContentType"
@@ -54,3 +65,86 @@ export const SlicesContent = t.type({
 })
 
 export type SlicesContent = t.TypeOf<typeof SlicesContent>
+
+export function traverseSlices({
+	path,
+	model,
+	content,
+}: {
+	path: ContentPath
+	content: SlicesContent
+	model?: StaticSlices | undefined
+}) {
+	return (transform: TraverseContentFn): SlicesContent => {
+		const value = content.value.reduce<SlicesContent["value"]>(
+			(acc, sliceContent) => {
+				const sliceModel: StaticSlice | undefined =
+					model?.config?.choices?.[sliceContent.name]
+
+				const slicePath = path.concat({
+					key: sliceContent.key,
+					type: sliceContent.widget.__TYPE__,
+				})
+
+				const convertedSliceWidget = (() => {
+					switch (sliceContent.widget.__TYPE__) {
+						case "SharedSliceContent":
+							return traverseSharedSliceContent({
+								path: slicePath,
+								sliceName: sliceContent.name,
+								model:
+									sliceModel && isStaticSharedSlice(sliceModel)
+										? sliceModel
+										: undefined,
+								content: sliceContent.widget,
+							})(transform)
+						case "CompositeSliceContent":
+							return traverseCompositeSliceContent({
+								path: slicePath,
+								sliceName: sliceContent.name,
+								model:
+									sliceModel && isCompositeSlice(sliceModel)
+										? sliceModel
+										: undefined,
+								content: sliceContent.widget,
+							})(transform)
+						case "GroupContentType":
+							return traverseGroupContent({
+								path: slicePath,
+								model:
+									sliceModel &&
+									isLegacySlice(sliceModel) &&
+									sliceModel.type === "Group"
+										? sliceModel
+										: undefined,
+								content: sliceContent.widget,
+							})(transform)
+						default:
+							return sliceContent.widget
+					}
+				})()
+
+				const convertedSlice = transform({
+					key: sliceContent.key,
+					apiId: sliceContent.name,
+					path: slicePath,
+					model: sliceModel,
+					content: convertedSliceWidget,
+				})
+
+				const convertedSliceParent = convertedSlice && {
+					...sliceContent,
+					widget: convertedSlice,
+				}
+
+				return convertedSliceParent ? acc.concat(convertedSliceParent) : acc
+			},
+			[],
+		)
+
+		return {
+			__TYPE__: content.__TYPE__,
+			value,
+		}
+	}
+}

package/src/customtypes/CustomType.ts

@@ -74,6 +74,23 @@ export function flattenWidgets(
 		[],
 	)
 }
+
+export function flattenStaticWidgets(
+	customType: StaticCustomType,
+): Array<[string, StaticWidget]> {
+	return Object.entries(customType.json).reduce(
+		(
+			acc: Array<[string, StaticWidget]>,
+			[, section]: [string, StaticSection],
+		) => {
+			const sectionWidgets: Array<[string, StaticWidget]> =
+				Object.entries(section)
+			return acc.concat(sectionWidgets)
+		},
+		[],
+	)
+}
+
 function _retrieveSharedSlicesRef(customType: CustomType): Array<string> {
 	const slicezones = flattenWidgets(customType).filter(
 		([, widget]: [string, DynamicWidget]) => widget.type === "Slices",

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -3,6 +3,7 @@ import * as t from "io-ts"
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
 import { NestableWidget } from "../nestable/NestableWidget"
+import type { DynamicSlice, StaticSlice } from "./Slice"
 
 export const CompositeSliceType = "Slice"
 
@@ -30,3 +31,9 @@ export const CompositeSlice = t.exact(
 	]),
 )
 export type CompositeSlice = t.TypeOf<typeof CompositeSlice>
+
+export function isCompositeSlice(
+	slice: DynamicSlice | StaticSlice,
+): slice is CompositeSlice {
+	return slice.type === "Slice"
+}

package/src/customtypes/widgets/slices/LegacySlice.ts

@@ -2,7 +2,14 @@ import * as t from "io-ts"
 
 import { Group } from "../Group"
 import { NestableWidget } from "../nestable/NestableWidget"
+import type { DynamicSlice, StaticSlice } from "./Slice"
 
 export const LegacySlice = t.union([NestableWidget, Group])
 
 export type LegacySlice = t.TypeOf<typeof LegacySlice>
+
+export function isLegacySlice(
+	slice: DynamicSlice | StaticSlice,
+): slice is LegacySlice {
+	return slice.type !== "Slice" && slice.type !== "SharedSlice"
+}

package/src/customtypes/widgets/slices/SharedSlice.ts

@@ -3,6 +3,8 @@ import { withFallback } from "io-ts-types/lib/withFallback"
 
 import { WidgetKey } from "../../../common"
 import { NestableWidget } from "../nestable/NestableWidget"
+import type { SharedSliceRef } from "./SharedSliceRef"
+import type { DynamicSlice, StaticSlice } from "./Slice"
 
 const IMAGE_PLACEHOLDER_URL =
 	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"
@@ -44,3 +46,13 @@ export const SharedSlice = t.exact(
 )
 
 export type SharedSlice = t.TypeOf<typeof SharedSlice>
+
+export function isStaticSharedSlice(slice: StaticSlice): slice is SharedSlice {
+	return slice.type === "SharedSlice"
+}
+
+export function isDynamicSharedSlice(
+	slice: DynamicSlice,
+): slice is SharedSliceRef {
+	return slice.type === "SharedSlice"
+}

package/src/import/converters/Document.ts

@@ -1,16 +1,17 @@
-import type { Asset, AssetId } from "../../common"
+import type { Asset, Embed } from "../../common"
 import type { Document, WidgetContent } from "../../content"
 import type { ImportDocument } from "../validators"
 import type { ImportField } from "../validators/fields/ImportField"
-import { convertNestableWidget, uidConverter } from "./fields"
+import { convertNestableWidget, importSlicesConverter } from "./fields"
 
 export function convertImportToContent(
 	document: ImportDocument,
-	assets: Record<AssetId, Asset>,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
 ): Document {
 	return Object.entries(document).reduce<Document>(
 		(acc, [fieldKey, fieldValue]) => {
-			const newFieldValue = convertWidget(fieldValue, assets)
+			const newFieldValue = convertWidget(fieldValue, assets, embeds)
 			return newFieldValue ? { ...acc, [fieldKey]: newFieldValue } : acc
 		},
 		{},
@@ -19,12 +20,13 @@ export function convertImportToContent(
 
 function convertWidget(
 	field: ImportField,
-	assets: Record<AssetId, Asset>,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
 ): WidgetContent | undefined {
 	switch (field.type) {
-		case "UID":
-			return uidConverter(field.value)
+		case "Slices":
+			return importSlicesConverter(field.value, assets, embeds)
 		default:
-			return convertNestableWidget(field, assets)
+			return convertNestableWidget(field, assets, embeds)
 	}
 }

package/src/import/converters/fields/Slices/SharedSlice.ts

@@ -0,0 +1,24 @@
+import { v4 as uuid } from "uuid"
+
+import type { Asset, Embed } from "../../../../common"
+import type { SliceItemContent } from "../../../../content"
+import type { SharedSlice as ImportSharedSlice } from "../../../validators/fields/ImportSlices/SharedSlice"
+import { importSharedSliceContentConverter } from "./SharedSliceContent"
+
+// TODO should we put it together with SharedSliceId validator?
+const buildSharedSliceId = (slice_type: string) => `${slice_type}$${uuid()}`
+
+export const sharedSliceConverter = (
+	slice: ImportSharedSlice,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SliceItemContent => {
+	// Right now we only support SharedSlices, if we support more types of slices in the future we'll need to select a correct converter here
+	const widget = importSharedSliceContentConverter(slice, assets, embeds)
+	return {
+		key: slice.id ?? buildSharedSliceId(slice.slice_type),
+		name: slice.slice_type,
+		maybeLabel: slice.slice_label ?? undefined,
+		widget,
+	}
+}

package/src/import/converters/fields/Slices/SharedSliceContent.ts

@@ -0,0 +1,94 @@
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+import * as R from "fp-ts/Record"
+
+import type { Asset, Embed } from "../../../../common"
+import type { NestableContent, SharedSliceContent } from "../../../../content"
+import {
+	GroupItemContentType,
+	SharedSliceContentType,
+} from "../../../../content"
+import type {
+	SharedSlice as ImportSharedSlice,
+	SharedSliceContent as ImportSharedSliceContent,
+} from "../../../validators/fields/ImportSlices/SharedSlice"
+import { convertNestableWidget } from "../nestable"
+
+/**
+ * Converts the ImportSharedSliceContent which is a record of widget keys and ImportNestable values to a record of widget keys and NestableContent values.
+ *
+ * @param content a single ImportSharedSliceContent
+ * @param assets assets that are required for a conversion of a nestable widget
+ * @param embeds embeds that are required for a conversion of a nestable widget
+ */
+const sharedSliceContentConverter = (
+	content: ImportSharedSliceContent,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): Record<string, NestableContent> =>
+	pipe(
+		content,
+		// convertNestableWidget can theoretically return undefined, so we need to filter out those values
+		R.filterMap((contentValue) =>
+			pipe(
+				contentValue,
+				(content) => convertNestableWidget(content, assets, embeds),
+				O.fromNullable,
+			),
+		),
+	)
+
+/**
+ * Converts a list of items to a list of repeatable widgets.
+ * Each ImportSharedSliceContent element is a record of fields, but in the content model it is represented as a list of tuples (key, value)
+ *
+ * For example, given the following slice content:
+ *  {
+ *  	"slice_text": (ImportNestable),
+ *  	"slice_number": (ImportNestable),
+ *  }
+ *
+ *  has to be converted to:
+ *
+ *  {
+ *      __TYPE__: "GroupItemContentType",
+ *      value: [
+ *      	["slice_text", (NestableContent)],
+ *      	["slice_number", (NestableContent)],
+ *      ]
+ *  }
+ *
+ *  @param items list of items to be converted
+ *  @param assets assets that are required for a conversion of a nestable widget
+ */
+const itemsConverter = (
+	items: ImportSharedSliceContent[],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SharedSliceContent["items"] =>
+	items.map((item) =>
+		pipe(
+			sharedSliceContentConverter(item, assets, embeds),
+			(record) => Object.entries(record),
+			(entries) => ({ __TYPE__: GroupItemContentType, value: entries }),
+		),
+	)
+
+/**
+ * Builds SharedSliceContent model from ImportSharedSlice
+ * @param field ImportSharedSlice to be converted - a single slice from the slices array in the import document
+ * @param assets assets that are required for a conversion of a nestable widget
+ * @param embeds embeds that are required for a conversion of a nestable widget
+ */
+export const importSharedSliceContentConverter = (
+	field: ImportSharedSlice,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SharedSliceContent => ({
+	__TYPE__: SharedSliceContentType,
+	primary: field.primary
+		? sharedSliceContentConverter(field.primary, assets, embeds)
+		: {},
+	items: field.items ? itemsConverter(field.items, assets, embeds) : [],
+	variation: field.variation,
+})

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

@@ -0,0 +1,20 @@
+import type { Asset, Embed } from "../../../../common"
+import type { SliceItemContent, SlicesContent } from "../../../../content"
+import type { ImportSlices } from "../../../validators/fields/ImportSlices"
+import { sharedSliceConverter } from "./SharedSlice"
+
+export const importSlicesConverter = (
+	field: ImportSlices["value"],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SlicesContent | undefined => {
+	if (field === null) return
+
+	return {
+		value: field.map((slice): SliceItemContent => {
+			// Right now we only support SharedSlices, if we support more types of slices in the future we'll need to select a correct converter here
+			return sharedSliceConverter(slice, assets, embeds)
+		}),
+		__TYPE__: "SliceContentType",
+	}
+}

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

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

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

@@ -1,11 +1,7 @@
 import type { UIDContent } from "../../../content"
 import type { ImportUID } from "../../validators/fields/UID"
 
-export const uidConverter = (
-	field: ImportUID["value"],
-): UIDContent | undefined => {
-	if (field === null) return
-
+export const uidConverter = (field: ImportUID["value"]): UIDContent => {
 	return {
 		value: field,
 		__TYPE__: "UIDContent",

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

@@ -1,2 +1,3 @@
 export * from "./nestable"
+export * from "./Slices"
 export * from "./UID"