prismic-ts-codegen 0.1.11 → 0.1.13

package/src/lib/buildFieldProperties.ts

@@ -0,0 +1,513 @@
+import {
+	CustomTypeModelField,
+	CustomTypeModelFieldType,
+	CustomTypeModelLinkSelectType,
+} from "@prismicio/client";
+import { source, stripIndent } from "common-tags";
+
+import { AuxiliaryType, FieldConfigs, FieldPath } from "../types";
+
+import { addLine } from "./addLine";
+import { addSection } from "./addSection";
+import { buildFieldDocs } from "./buildFieldDocs";
+import { buildTypeName } from "./buildTypeName";
+import { buildUnion } from "./buildUnion";
+import { getHumanReadablePath } from "./getHumanReadablePath";
+
+type BuildFieldPropertyArgs = Pick<
+	BuildFieldPropertiesArgs,
+	"path" | "fieldConfigs" | "tabName"
+> & {
+	name: string;
+	field: CustomTypeModelField;
+};
+
+type BuildFieldPropertyReturnType = {
+	code: string;
+	auxiliaryTypes: AuxiliaryType[];
+};
+
+function buildFieldProperty(
+	args: BuildFieldPropertyArgs,
+): BuildFieldPropertyReturnType {
+	let code = buildFieldDocs({
+		name: args.name,
+		field: args.field,
+		path: args.path,
+		tabName: args.tabName,
+	});
+
+	const auxiliaryTypes: AuxiliaryType[] = [];
+
+	const name =
+		args.name.includes("-") ||
+		args.name.includes(":") ||
+		/^[0-9]/.test(args.name)
+			? `"${args.name}"`
+			: args.name;
+
+	switch (args.field.type) {
+		case CustomTypeModelFieldType.UID: {
+			// UID fields are not included in Data.
+			break;
+		}
+
+		case CustomTypeModelFieldType.Boolean: {
+			code = addLine(`${name}: prismic.BooleanField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Color: {
+			code = addLine(`${name}: prismic.ColorField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Date: {
+			code = addLine(`${name}: prismic.DateField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Embed: {
+			const providerTypes: string[] = [];
+
+			if (args.fieldConfigs.embed?.providerTypes) {
+				for (const providerType in args.fieldConfigs.embed?.providerTypes) {
+					const configuredProviderType =
+						args.fieldConfigs.embed?.providerTypes[providerType];
+
+					providerTypes.push(
+						`({ provider_name: "${providerType}" } & ${configuredProviderType})`,
+					);
+				}
+			}
+
+			const providerTypesUnion = buildUnion(providerTypes);
+
+			code =
+				providerTypes.length > 0
+					? addLine(
+							`${name}: prismic.EmbedField<prismic.AnyOEmbed & prismic.OEmbedExtra & (${providerTypesUnion})>`,
+							code,
+					  )
+					: addLine(`${name}: prismic.EmbedField`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.GeoPoint: {
+			code = addLine(`${name}: prismic.GeoPointField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Image: {
+			if (
+				args.field.config?.thumbnails &&
+				args.field.config.thumbnails.length > 0
+			) {
+				const thumbnailNames = buildUnion(
+					args.field.config.thumbnails.map((thumb) => `"${thumb.name}"`),
+				);
+
+				code = addLine(`${name}: prismic.ImageField<${thumbnailNames}>;`, code);
+			} else {
+				code = addLine(`${name}: prismic.ImageField<never>;`, code);
+			}
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Integration: {
+			const catalogType = args.field.config?.catalog
+				? args.fieldConfigs.integrationFields?.catalogTypes?.[
+						args.field.config.catalog
+				  ]
+				: undefined;
+
+			if (catalogType) {
+				code = addLine(
+					`${name}: prismic.IntegrationField<${catalogType}>;`,
+					code,
+				);
+			} else {
+				code = addLine(`${name}: prismic.IntegrationField;`, code);
+			}
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Link: {
+			switch (args.field.config?.select) {
+				case CustomTypeModelLinkSelectType.Document: {
+					if (
+						"customtypes" in args.field.config &&
+						args.field.config.customtypes &&
+						args.field.config.customtypes.length > 0
+					) {
+						const customTypeIDsUnion = buildUnion(
+							args.field.config.customtypes.map((type) => `"${type}"`),
+						);
+
+						code = addLine(
+							`${name}: prismic.ContentRelationshipField<${customTypeIDsUnion}>;`,
+							code,
+						);
+					} else {
+						code = addLine(`${name}: prismic.ContentRelationshipField;`, code);
+					}
+
+					break;
+				}
+
+				case CustomTypeModelLinkSelectType.Media: {
+					code = addLine(`${name}: prismic.LinkToMediaField;`, code);
+
+					break;
+				}
+
+				default: {
+					code = addLine(`${name}: prismic.LinkField;`, code);
+				}
+			}
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Number: {
+			code = addLine(`${name}: prismic.NumberField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.StructuredText: {
+			const isTitleField =
+				args.field.config &&
+				"single" in args.field.config &&
+				args.field.config.single &&
+				args.field.config.single
+					.split(",")
+					.every((blockType) => /heading/.test(blockType));
+
+			if (isTitleField) {
+				code = addLine(`${name}: prismic.TitleField;`, code);
+			} else {
+				code = addLine(`${name}: prismic.RichTextField;`, code);
+			}
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Select: {
+			const options: string[] =
+				args.field.config?.options?.map((option) => `"${option}"`) || [];
+			const optionsType = options.length ? buildUnion(options) : "string";
+
+			const hasDefault = Boolean(args.field.config?.default_value);
+
+			if (hasDefault) {
+				code = addLine(
+					`${name}: prismic.SelectField<${optionsType}, "filled">;`,
+					code,
+				);
+			} else {
+				code = addLine(
+					`${name}: prismic.SelectField${
+						options.length > 0 ? `<${optionsType}>` : ""
+					};`,
+					code,
+				);
+			}
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Text: {
+			code = addLine(`${name}: prismic.KeyTextField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Timestamp: {
+			code = addLine(`${name}: prismic.TimestampField;`, code);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Group: {
+			const itemName = buildTypeName(
+				args.path[0].name,
+				"Document",
+				"Data",
+				args.name,
+				"Item",
+			);
+
+			const path: FieldPath = [
+				...args.path,
+				{
+					name: name,
+					model: args.field,
+				},
+			];
+			const humanReadablePath = getHumanReadablePath({ path });
+
+			const itemFieldProperties = buildFieldProperties({
+				fields: args.field.config?.fields || {},
+				fieldConfigs: args.fieldConfigs,
+				path,
+			});
+
+			auxiliaryTypes.push({
+				name: itemName,
+				code: source`
+					/**
+					 * Item in *${humanReadablePath}*
+					 */
+					export interface ${itemName} {
+						${itemFieldProperties.code}
+					}
+				`,
+			});
+
+			code = addLine(
+				`${name}: prismic.GroupField<Simplify<${itemName}>>;`,
+				code,
+			);
+
+			break;
+		}
+
+		case CustomTypeModelFieldType.Slices: {
+			const choiceNames: string[] = [];
+
+			if (args.field.config?.choices) {
+				for (const choiceID in args.field.config.choices) {
+					const choice = args.field.config.choices[choiceID];
+
+					if (choice.type === "SharedSlice") {
+						// TODO: Verify that the Shared Slice
+						// is provided to the global
+						// `sharedSlices` array. If it is not,
+						// the type won't exist, so we can't
+						// add it to the union. We should
+						// probably throw an error if we reach
+						// that state, or maybe the input can
+						// be validated early so we don't
+						// generate any code using invalid
+						// models.
+						choiceNames.push(buildTypeName(choiceID, "Slice"));
+					} else if (choice.type === "Slice") {
+						const sliceName = buildTypeName(
+							args.path[0].name,
+							"Document",
+							"Data",
+							args.name,
+							choiceID,
+							"Slice",
+						);
+
+						let primaryInterfaceName: string | undefined;
+						if (
+							choice["non-repeat"] &&
+							Object.keys(choice["non-repeat"]).length > 0
+						) {
+							primaryInterfaceName = buildTypeName(sliceName, "Primary");
+
+							const path: FieldPath = [
+								...args.path,
+								{
+									name: args.name,
+									model: args.field,
+								},
+								{
+									name: choiceID,
+									model: choice,
+								},
+								{
+									name: "primary",
+									label: "Primary",
+								},
+							];
+							const humanReadablePath = getHumanReadablePath({ path });
+
+							const primaryFieldProperties = buildFieldProperties({
+								fields: choice["non-repeat"],
+								fieldConfigs: args.fieldConfigs,
+								path,
+							});
+
+							let primaryCode = stripIndent`
+								/**
+								 * Primary content in *${humanReadablePath}*
+								 */
+							`;
+							primaryCode = primaryFieldProperties.code
+								? addLine(
+										source`
+											export interface ${primaryInterfaceName} {
+												${primaryFieldProperties.code}
+											}
+										`,
+										primaryCode,
+								  )
+								: addLine(
+										`export interface ${primaryInterfaceName} {}`,
+										primaryCode,
+								  );
+
+							auxiliaryTypes.push({
+								name: primaryInterfaceName,
+								code: primaryCode,
+							});
+						}
+
+						let itemInterfaceName: string | undefined;
+						if (choice.repeat && Object.keys(choice.repeat).length > 0) {
+							itemInterfaceName = buildTypeName(sliceName, "Item");
+
+							const path: FieldPath = [
+								...args.path,
+								{
+									name: args.name,
+									model: args.field,
+								},
+								{
+									name: choiceID,
+									model: choice,
+								},
+								{
+									name: "items",
+									label: "Items",
+								},
+							];
+							const humanReadablePath = getHumanReadablePath({ path });
+
+							const itemFieldProperties = buildFieldProperties({
+								fields: choice.repeat,
+								fieldConfigs: args.fieldConfigs,
+								path,
+							});
+
+							let itemCode = stripIndent`
+								/**
+								 * Item content in *${humanReadablePath}*
+								 */
+							`;
+							itemCode = itemFieldProperties.code
+								? addLine(
+										source`
+											export interface ${itemInterfaceName} {
+												${itemFieldProperties.code}
+											}
+										`,
+										itemCode,
+								  )
+								: addLine(`export interface ${itemInterfaceName} {}`, itemCode);
+
+							auxiliaryTypes.push({
+								name: itemInterfaceName,
+								code: itemCode,
+							});
+						}
+
+						auxiliaryTypes.push({
+							name: sliceName,
+							code: stripIndent`
+								/**
+								 * Slice for *${getHumanReadablePath({
+										path: [
+											...args.path,
+											{
+												name: args.name,
+												model: args.field,
+											},
+										],
+									})}*
+								 */
+								export type ${sliceName} = prismic.Slice<"${choiceID}", ${
+								primaryInterfaceName
+									? `Simplify<${primaryInterfaceName}>`
+									: `Record<string, never>`
+							}, ${
+								itemInterfaceName ? `Simplify<${itemInterfaceName}>` : `never`
+							}>
+							`,
+						});
+
+						choiceNames.push(sliceName);
+					}
+				}
+			}
+
+			const choiceUnionName = buildTypeName(
+				args.path[0].name,
+				"Document",
+				"Data",
+				args.name,
+				"Slice",
+			);
+			const choiceUnion = buildUnion(choiceNames);
+			auxiliaryTypes.push({
+				name: choiceUnionName,
+				code: `type ${choiceUnionName} = ${choiceUnion}`,
+			});
+
+			code = addLine(`${name}: prismic.SliceZone<${choiceUnionName}>;`, code);
+
+			break;
+		}
+
+		default: {
+			code = addLine(`${name}: unknown;`, code);
+		}
+	}
+
+	return {
+		code,
+		auxiliaryTypes,
+	};
+}
+
+type BuildFieldPropertiesArgs = {
+	fields: Record<string, CustomTypeModelField>;
+	path: FieldPath;
+	fieldConfigs: FieldConfigs;
+	tabName?: string;
+};
+
+type BuildFieldPropertiesReturnType = {
+	code: string;
+	auxiliaryTypes: AuxiliaryType[];
+};
+
+export function buildFieldProperties(
+	args: BuildFieldPropertiesArgs,
+): BuildFieldPropertiesReturnType {
+	let code = "";
+
+	const auxiliaryTypes: AuxiliaryType[] = [];
+
+	for (const name in args.fields) {
+		const field = args.fields[name];
+
+		const fieldProperty = buildFieldProperty({
+			name,
+			field,
+			path: args.path,
+			fieldConfigs: args.fieldConfigs,
+			tabName: args.tabName,
+		});
+
+		code = addSection(fieldProperty.code, code);
+
+		auxiliaryTypes.push(...fieldProperty.auxiliaryTypes);
+	}
+
+	return {
+		code,
+		auxiliaryTypes,
+	};
+}

package/src/lib/buildSharedSliceType.ts

@@ -0,0 +1,213 @@
+import { SharedSliceModel } from "@prismicio/client";
+import { source, stripIndent } from "common-tags";
+import QuickLRU from "quick-lru";
+
+import { FieldConfigs, FieldPath } from "../types";
+
+import { SHARED_SLICES_DOCUMENTATION_URL } from "../constants";
+
+import { addSection } from "./addSection";
+import { buildFieldProperties } from "./buildFieldProperties";
+import { buildTypeName } from "./buildTypeName";
+import { buildUnion } from "./buildUnion";
+import { getCacheKey } from "./getCacheKey";
+import { getHumanReadableModelName } from "./getHumanReadableModelName";
+import { getHumanReadablePath } from "./getHumanReadablePath";
+
+type BuildSharedSliceTypeArgs = {
+	model: SharedSliceModel;
+	fieldConfigs: FieldConfigs;
+	cache?: QuickLRU<string, unknown>;
+};
+
+type BuildSharedSliceTypeReturnValue = {
+	name: string;
+	variationUnionName: string;
+	variationNames: string[];
+	code: string;
+};
+
+export function buildSharedSliceType(
+	args: BuildSharedSliceTypeArgs,
+): BuildSharedSliceTypeReturnValue {
+	if (args.cache) {
+		const key = getCacheKey([args.model, args.fieldConfigs]);
+		const cached = args.cache.get(key);
+
+		if (cached) {
+			return cached as BuildSharedSliceTypeReturnValue;
+		}
+	}
+
+	let code = "";
+
+	const name = buildTypeName(args.model.id, "Slice");
+	const humanReadableName = getHumanReadableModelName({
+		name: args.model.id,
+		model: args.model,
+	});
+
+	const variationNames: string[] = [];
+	for (const variationModel of args.model.variations) {
+		const variationName = buildTypeName(name, variationModel.id);
+
+		let primaryInterfaceName: string | undefined;
+		if (
+			variationModel.primary &&
+			Object.keys(variationModel.primary).length > 0
+		) {
+			primaryInterfaceName = buildTypeName(variationName, "Primary");
+
+			const path: FieldPath = [
+				{
+					name: args.model.id,
+					model: args.model,
+				},
+				{
+					name: "primary",
+					label: "Primary",
+				},
+			];
+			const humanReadablePath = getHumanReadablePath({ path });
+
+			const primaryFieldProperties = buildFieldProperties({
+				fields: variationModel.primary,
+				fieldConfigs: args.fieldConfigs,
+				path,
+			});
+
+			const docs = stripIndent`
+				/**
+				 * Primary content in *${humanReadablePath}*
+				 */
+			`;
+
+			code = addSection(
+				primaryFieldProperties.code
+					? source`
+						${docs}
+						export interface ${primaryInterfaceName} {
+							${primaryFieldProperties.code}
+						}
+					`
+					: source`
+						${docs}
+						export interface ${primaryInterfaceName} {}
+					`,
+				code,
+			);
+		}
+
+		let itemInterfaceName: string | undefined;
+		if (variationModel.items && Object.keys(variationModel.items).length > 0) {
+			itemInterfaceName = buildTypeName(variationName, "Item");
+
+			const path: FieldPath = [
+				{
+					name: args.model.id,
+					model: args.model,
+				},
+				{
+					name: "items",
+					label: "Items",
+				},
+			];
+			const humanReadablePath = getHumanReadablePath({ path });
+
+			const itemFieldProperties = buildFieldProperties({
+				fields: variationModel.items,
+				fieldConfigs: args.fieldConfigs,
+				path,
+			});
+
+			const docs = stripIndent`
+				/**
+				 * Primary content in *${humanReadablePath}*
+				 */
+			`;
+
+			code = addSection(
+				itemFieldProperties.code
+					? source`
+						${docs}
+						export interface ${itemInterfaceName} {
+							${itemFieldProperties.code}
+						}
+					`
+					: source`
+						${docs}
+						export interface ${itemInterfaceName} {}
+					`,
+				code,
+			);
+		}
+
+		code = addSection(
+			source`
+				/**
+				 * ${variationModel.name} variation for ${humanReadableName} Slice
+				 *
+				 * - **API ID**: \`${variationModel.id}\`
+				 * - **Description**: ${variationModel.description || "*None*"}
+				 * - **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}
+				 */
+				export type ${variationName} = prismic.SharedSliceVariation<"${
+				variationModel.id
+			}", ${
+				primaryInterfaceName
+					? `Simplify<${primaryInterfaceName}>`
+					: `Record<string, never>`
+			}, ${itemInterfaceName ? `Simplify<${itemInterfaceName}>` : `never`}>;
+			`,
+			code,
+		);
+
+		variationNames.push(variationName);
+	}
+
+	const variationUnionName = buildTypeName(name, "Variation");
+	const variationsUnion = buildUnion(variationNames);
+
+	code = addSection(
+		source`
+			/**
+			 * Slice variation for *${humanReadableName}*
+			 */
+			type ${variationUnionName} = ${
+			variationNames.length > 0 ? variationsUnion : "never"
+		}
+		`,
+		code,
+	);
+
+	code = addSection(
+		source`
+			/**
+			 * ${humanReadableName} Shared Slice
+			 *
+			 * - **API ID**: \`${args.model.id}\`
+			 * - **Description**: ${args.model.description || "*None*"}
+			 * - **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}
+			 */
+			export type ${name} = prismic.SharedSlice<"${
+			args.model.id
+		}", ${variationUnionName}>;
+		`,
+		code,
+	);
+
+	const result = {
+		name,
+		variationUnionName,
+		variationNames,
+		code,
+	};
+
+	if (args.cache) {
+		const key = getCacheKey([args.model, args.fieldConfigs]);
+
+		args.cache.set(key, result);
+	}
+
+	return result;
+}