@prismicio/types-internal 2.1.0-alpha.2 → 2.1.0-alpha.4

package/lib/customtypes/widgets/slices/Slices.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
+exports.traverseSlices = exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const common_1 = require("../../../common");
 const validators_1 = require("../../../validators");
+const utils_1 = require("../../_internal/utils");
+const Group_1 = require("../Group");
 const CompositeSlice_1 = require("./CompositeSlice");
 const LegacySlice_1 = require("./LegacySlice");
 const SharedSlice_1 = require("./SharedSlice");
@@ -78,3 +80,34 @@ exports.Slices = {
         }
     },
 };
+function traverseSlices(path, slices, f) {
+    var _a, _b, _c, _d;
+    const entries = ((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices) &&
+        Object.entries(slices.config.choices).map(([sliceKey, sliceValue]) => {
+            const slicePath = path.concat(sliceKey);
+            switch (sliceValue.type) {
+                case "SharedSlice":
+                    return [sliceKey, f(sliceValue, sliceKey, slicePath)];
+                case "Slice":
+                    return [
+                        sliceKey,
+                        f((0, CompositeSlice_1.traverseCompositeSlice)(slicePath, sliceValue, f), sliceKey, slicePath),
+                    ];
+                case "Group":
+                    return [sliceKey, (0, Group_1.traverseGroup)(slicePath, sliceValue, f)];
+                default:
+                    return [sliceKey, f(sliceValue, sliceKey, slicePath)];
+            }
+        });
+    return {
+        ...slices,
+        config: {
+            ...(((_b = slices.config) === null || _b === void 0 ? void 0 : _b.label) ? { label: slices.config.label } : {}),
+            ...(((_c = slices.config) === null || _c === void 0 ? void 0 : _c.labels) ? { labels: slices.config.labels } : {}),
+            ...(((_d = slices.config) === null || _d === void 0 ? void 0 : _d.choices) && entries
+                ? { choices: (0, utils_1.fromEntriesWithValue)(entries) }
+                : {}),
+        },
+    };
+}
+exports.traverseSlices = traverseSlices;

package/lib/validators/StringOrT.d.ts

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

@@ -0,0 +1,15 @@
+"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/package.json

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

package/src/content/Document.ts

@@ -4,7 +4,7 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
 import { WidgetKey } from "../common"
-import { isUIDContent, WidgetContent, WidgetLegacy } from "./fields"
+import { WidgetContent, WidgetLegacy } from "./fields"
 import {
 	defaultCtx,
 	FieldOrSliceType,
@@ -97,11 +97,7 @@ function extractMetadata(data: { [p: string]: unknown }): {
 	)
 
 	const slugs = (data["slugs_INTERNAL"] as string[]) || []
-	const uid = (() => {
-		const rawUID = data["uid"]
-		if (isUIDContent(rawUID)) return rawUID.value
-		return
-	})()
+	const uid = data["uid"] as string | undefined
 
 	return {
 		widgets,

package/src/customtypes/CustomType.ts

@@ -1,12 +1,16 @@
-import { Either, left, right } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
 import { StringOrNull } from "../validators"
-import { DynamicSection, Sections, StaticSection } from "./Section"
+import { fromEntriesWithValue, TraverseFn } from "./_internal/utils"
+import {
+	DynamicSection,
+	Sections,
+	StaticSection,
+	traverseSection,
+} from "./Section"
 import type { SharedSlice } from "./widgets/slices/SharedSlice"
 import type { DynamicSlice } from "./widgets/slices/Slice"
-import type { DynamicSlices } from "./widgets/slices/Slices"
 import type { DynamicWidget } from "./widgets/Widget"
 
 export const CustomTypeFormat = {
@@ -14,24 +18,6 @@ export const CustomTypeFormat = {
 	custom: "custom",
 }
 
-class CustomTypeSlicesError extends Error {
-	slices: Array<string>
-	override message: string
-
-	constructor(slices: Array<string>) {
-		super()
-		this.slices = slices
-		this.message = this._formatError(slices)
-	}
-
-	_formatError(slicesRefs: Array<string>) {
-		const slicesMsg = slicesRefs.map((ref) => `\t - ${ref}`)
-		return `The following slices doesn't exists in your Prismic repository:
-${slicesMsg.join("\n")}
-`
-	}
-}
-
 function customTypeReader<T extends StaticSection | DynamicSection>(
 	codec: t.Type<T, unknown>,
 ) {
@@ -73,39 +59,6 @@ export function flattenWidgets(
 		[],
 	)
 }
-function _retrieveSharedSlicesRef(customType: CustomType): Array<string> {
-	const slicezones = flattenWidgets(customType).filter(
-		([, widget]: [string, DynamicWidget]) => widget.type === "Slices",
-	) as Array<[string, DynamicSlices]>
-
-	const allSharedRefs = slicezones.reduce(
-		(acc: Array<string>, [, slicezone]) => {
-			const sharedRefs = Object.entries(
-				slicezone.config && slicezone.config.choices
-					? slicezone.config.choices
-					: {},
-			)
-				.filter(
-					([, slice]: [string, DynamicSlice]) => slice.type === "SharedSlice",
-				)
-				.map(([key]) => key)
-			return acc.concat(sharedRefs)
-		},
-		[],
-	)
-
-	return allSharedRefs
-}
-
-function _mapSharedSlicesRefs<A>(
-	customType: CustomType,
-): (mapFn: (ref: string) => A) => Array<A> {
-	const refs = _retrieveSharedSlicesRef(customType)
-
-	return function (mapFn: (ref: string) => A): Array<A> {
-		return refs.map(mapFn)
-	}
-}
 
 export function toStatic(
 	customType: CustomType,
@@ -127,53 +80,11 @@ export function toStatic(
 	return { ...customType, json } as StaticCustomType
 }
 
-export function validateSlices(
-	customType: CustomType,
-	sharedSlices: Map<string, SharedSlice>,
-): Either<CustomTypeSlicesError, CustomType> {
-	const missingSlices = _mapSharedSlicesRefs<string | undefined>(customType)(
-		(ref: string) => {
-			const slice: SharedSlice | undefined = sharedSlices.get(ref)
-			const isMissing = !slice
-			if (isMissing) return ref
-			return
-		},
-	).filter(Boolean) as Array<string>
-
-	if (missingSlices.length > 0)
-		return left(new CustomTypeSlicesError(missingSlices))
-	else return right(customType)
-}
-
-export function collectWidgets(
-	customType: CustomType,
-	f: (ref: string, widget: DynamicWidget) => DynamicWidget | undefined,
-): CustomType {
-	const json = Object.entries(customType.json).reduce(
-		(acc, [sectionId, section]: [string, DynamicSection]) => {
-			const updatedSection = Object.entries(section).reduce(
-				(acc, [ref, widget]) => {
-					const updatedWidget = f(ref, widget)
-					if (updatedWidget) {
-						return { ...acc, [ref]: updatedWidget }
-					}
-					return acc
-				},
-				{},
-			)
-			return { ...acc, [sectionId]: updatedSection }
-		},
-		{},
-	)
-
-	return { ...customType, json }
-}
-
 export function filterMissingSharedSlices(
 	customType: CustomType,
 	sharedSlices: Map<string, SharedSlice>,
 ): CustomType {
-	return collectWidgets(customType, (_widgetId, widget) => {
+	return traverseCustomType(customType, (widget) => {
 		if (widget.type === "Slices") {
 			if (!widget.config || !widget.config.choices) return widget
 
@@ -194,3 +105,19 @@ export function filterMissingSharedSlices(
 		return widget
 	})
 }
+
+export function traverseCustomType(
+	customType: CustomType,
+	f: TraverseFn,
+): CustomType {
+	const ctEntries = Object.entries(customType.json).map(
+		([sectionId, section]: [string, DynamicSection]) => {
+			return [sectionId, traverseSection([sectionId], section, f)]
+		},
+	)
+
+	return {
+		...customType,
+		json: fromEntriesWithValue(ctEntries),
+	}
+}

package/src/customtypes/Section.ts

@@ -1,7 +1,9 @@
 import * as t from "io-ts"
 
 import { WidgetKey } from "../common"
-import type { SharedSlice } from "./widgets/slices"
+import { fromEntriesWithValue, TraverseFn } from "./_internal/utils"
+import { traverseGroup } from "./widgets"
+import { SharedSlice, traverseSlices } from "./widgets/slices"
 import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget"
 
 export function sectionReader<T extends StaticWidget | DynamicWidget>(
@@ -33,3 +35,28 @@ export const Sections = {
 		return section as StaticSection
 	},
 }
+
+export function traverseSection(
+	path: ReadonlyArray<string>,
+	section: DynamicSection,
+	f: TraverseFn,
+): DynamicSection {
+	const updatedSection = Object.entries(section).map(([key, widget]) => {
+		const widgetPath = path.concat(key)
+
+		const widgetOutput = (() => {
+			switch (widget.type) {
+				case "Choice":
+				case "Slices":
+					return traverseSlices(widgetPath, widget, f)
+				case "Group":
+					return traverseGroup(widgetPath, widget, f)
+				default:
+					return f(widget, key, widgetPath)
+			}
+		})()
+		return [key, widgetOutput && f(widgetOutput, key, widgetPath)]
+	})
+
+	return fromEntriesWithValue(updatedSection)
+}

package/src/customtypes/_internal/utils.ts

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

@@ -2,6 +2,7 @@ import * as t from "io-ts"
 
 import { WidgetKey } from "../../common"
 import { StringOrNull } from "../../validators"
+import { fromEntriesWithValue, TraverseFn } from "../_internal/utils"
 import { NestableWidget } from "./nestable/NestableWidget"
 
 export const GroupFieldType = "Group"
@@ -28,3 +29,26 @@ export const Group = t.exact(
 	]),
 )
 export type Group = t.TypeOf<typeof Group>
+
+export function traverseGroup(
+	path: ReadonlyArray<string>,
+	group: Group,
+	f: TraverseFn,
+): Group | undefined {
+	const entries =
+		group.config?.fields &&
+		Object.entries(group.config.fields).map(([widgetKey, widgetValue]) => {
+			return [widgetKey, f(widgetValue, widgetKey, path.concat(widgetKey))]
+		})
+
+	const config = group.config && {
+		...group.config,
+		...(group.config.fields && entries
+			? { fields: fromEntriesWithValue(entries) }
+			: {}),
+	}
+	return {
+		...group,
+		...(config ? { config } : {}),
+	}
+}

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

@@ -1,55 +1,6 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
-// This allow to parse an element that is either a string or a type T and convert the string to T if necessary so we get a consistent output.
-const StringOrT = <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,
-		)
-}
-
-/*
- * The models have slight differences if they are nested or not to avoid recursion and so an infinite level of nesting which would be incompatible with the Content API mechanism to resolve nested content.
- */
-
-const SimpleFieldResolver = StringOrT(
-	t.type({
-		fieldId: t.string,
-	}),
-)((id) => ({ fieldId: id }))
-
-type SimpleFieldResolver = t.TypeOf<typeof SimpleFieldResolver>
-
-const NestedCustomTypeResolver = t.type({
-	customTypeId: t.string,
-	fields: t.readonlyArray(SimpleFieldResolver),
-})
-type NestedCustomTypeResolver = t.TypeOf<typeof NestedCustomTypeResolver>
-
-const FieldResolver = StringOrT(
-	t.intersection([
-		t.type({
-			fieldId: t.string,
-		}),
-		t.partial({
-			customTypes: t.readonlyArray(NestedCustomTypeResolver),
-		}),
-	]),
-)((id) => ({ fieldId: id }))
-type FieldResolver = t.TypeOf<typeof FieldResolver>
+import StringOrT from "../../../../validators/StringOrT"
 
 const CustomTypeResolver = StringOrT(
 	t.intersection([
@@ -57,13 +8,13 @@ const CustomTypeResolver = StringOrT(
 			customTypeId: t.string,
 		}),
 		t.partial({
-			fields: t.readonlyArray(FieldResolver),
+			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
+export const ContentRelationshipResolver = t.readonlyArray(CustomTypeResolver)
+export type ContentRelationshipResolver = t.TypeOf<
+	typeof ContentRelationshipResolver
 >

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

@@ -3,7 +3,7 @@ import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
 import { StringOrNull } from "../../../../validators"
-import { ContentRelationShipResolver } from "./ContentRelationshipResolver"
+import { ContentRelationshipResolver } from "./ContentRelationshipResolver"
 
 const arrayString = (
 	entries:
@@ -75,7 +75,7 @@ export const LinkConfig = t.exact(
 			]),
 			null,
 		),
-		customtypes: ContentRelationShipResolver,
+		customtypes: ContentRelationshipResolver,
 		masks: MasksArrayString,
 		tags: MasksArrayString,
 		allowTargetBlank: t.boolean,

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

@@ -2,6 +2,7 @@ import * as t from "io-ts"
 
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
+import { fromEntriesWithValue, TraverseFn } from "../../_internal/utils"
 import { NestableWidget } from "../nestable/NestableWidget"
 
 export const CompositeSliceType = "Slice"
@@ -30,3 +31,35 @@ export const CompositeSlice = t.exact(
 	]),
 )
 export type CompositeSlice = t.TypeOf<typeof CompositeSlice>
+
+export function traverseCompositeSlice(
+	path: ReadonlyArray<string>,
+	slice: CompositeSlice,
+	f: TraverseFn,
+): CompositeSlice {
+	const primaryEntries =
+		slice["non-repeat"] &&
+		Object.entries(slice["non-repeat"]).map(([widgetKey, widgetValue]) => {
+			return [
+				widgetKey,
+				f(widgetValue, widgetKey, path.concat(["non-repeat", widgetKey])),
+			]
+		})
+
+	const itemsEntries =
+		slice.repeat &&
+		Object.entries(slice.repeat).map(([widgetKey, widgetValue]) => {
+			return [
+				widgetKey,
+				f(widgetValue, widgetKey, path.concat(["repeat", widgetKey])),
+			]
+		})
+
+	return {
+		...slice,
+		...(primaryEntries
+			? { "non-repeat": fromEntriesWithValue(primaryEntries) }
+			: {}),
+		...(itemsEntries ? { repeat: fromEntriesWithValue(itemsEntries) } : {}),
+	}
+}

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

@@ -2,6 +2,7 @@ import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
 import { WidgetKey } from "../../../common"
+import { fromEntriesWithValue, TraverseFn } from "../../_internal/utils"
 import { NestableWidget } from "../nestable/NestableWidget"
 
 const IMAGE_PLACEHOLDER_URL =
@@ -44,3 +45,49 @@ export const SharedSlice = t.exact(
 )
 
 export type SharedSlice = t.TypeOf<typeof SharedSlice>
+
+function traverseVariation(
+	path: ReadonlyArray<string>,
+	variation: Variation,
+	f: TraverseFn,
+): Variation {
+	const primaryEntries =
+		variation.primary &&
+		Object.entries(variation.primary).map(([widgetKey, widgetValue]) => {
+			return [
+				widgetKey,
+				f(widgetValue, widgetKey, path.concat(["primary", widgetKey])),
+			]
+		})
+
+	const itemsEntries =
+		variation.items &&
+		Object.entries(variation.items).map(([widgetKey, widgetValue]) => {
+			return [
+				widgetKey,
+				f(widgetValue, widgetKey, path.concat(["items", widgetKey])),
+			]
+		})
+
+	return {
+		...variation,
+		...(primaryEntries
+			? { primary: fromEntriesWithValue(primaryEntries) }
+			: {}),
+		...(itemsEntries ? { items: fromEntriesWithValue(itemsEntries) } : {}),
+	}
+}
+
+export function traverseSharedSlice(
+	slice: SharedSlice,
+	f: TraverseFn,
+): SharedSlice {
+	const variations = slice.variations.reduce<Array<Variation>>((acc, v) => {
+		return acc.concat(traverseVariation([v.id], v, f))
+	}, [])
+
+	return {
+		...slice,
+		variations,
+	}
+}

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

@@ -2,7 +2,9 @@ import * as t from "io-ts"
 
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
-import { CompositeSlice } from "./CompositeSlice"
+import { fromEntriesWithValue, TraverseFn } from "../../_internal/utils"
+import { traverseGroup } from "../Group"
+import { CompositeSlice, traverseCompositeSlice } from "./CompositeSlice"
 import { LegacySlice } from "./LegacySlice"
 import { SharedSlice } from "./SharedSlice"
 import { SharedSliceRef } from "./SharedSliceRef"
@@ -110,3 +112,44 @@ export const Slices = {
 		}
 	},
 }
+
+export function traverseSlices(
+	path: ReadonlyArray<string>,
+	slices: DynamicSlices,
+	f: TraverseFn,
+): DynamicSlices {
+	const entries =
+		slices.config?.choices &&
+		Object.entries(slices.config.choices).map(([sliceKey, sliceValue]) => {
+			const slicePath = path.concat(sliceKey)
+
+			switch (sliceValue.type) {
+				case "SharedSlice":
+					return [sliceKey, f(sliceValue, sliceKey, slicePath)]
+				case "Slice":
+					return [
+						sliceKey,
+						f(
+							traverseCompositeSlice(slicePath, sliceValue, f),
+							sliceKey,
+							slicePath,
+						),
+					]
+				case "Group":
+					return [sliceKey, traverseGroup(slicePath, sliceValue, f)]
+				default:
+					return [sliceKey, f(sliceValue, sliceKey, slicePath)]
+			}
+		})
+
+	return {
+		...slices,
+		config: {
+			...(slices.config?.label ? { label: slices.config.label } : {}),
+			...(slices.config?.labels ? { labels: slices.config.labels } : {}),
+			...(slices.config?.choices && entries
+				? { choices: fromEntriesWithValue(entries) }
+				: {}),
+		},
+	}
+}

package/src/validators/StringOrT.ts

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