prismic-ts-codegen 0.1.10 → 0.1.12

package/src/lib/buildFieldDocs.ts

@@ -1,75 +1,135 @@
-import type {
-	CustomTypeModel,
-	CustomTypeModelField,
-	CustomTypeModelSlice,
-	SharedSliceModel,
-} from "@prismicio/client";
-import type { JSDocableNodeStructure } from "ts-morph";
+import { CustomTypeModelField } from "@prismicio/client";
 
-import { PathElement } from "../types";
+import { FieldPath } from "../types";
 
+import { FIELD_DOCUMENTATION_URLS } from "../constants";
+
+import { addLine } from "./addLine";
 import { getAPIIDPath } from "./getAPIIDPath";
-import { getFieldDocumentationURL } from "./getFieldDocumentationURL";
-import { getHumanReadableFieldPath } from "./getHumanReadableFieldPath";
-import { getHumanReadableFieldType } from "./getHumanReadableFieldType";
 import { getHumanReadableModelName } from "./getHumanReadableModelName";
-import { writeFieldDocsDescription } from "./writeFieldDocsDescription";
-
-type BuildFieldDocsConfig = {
-	id: string;
-	model: CustomTypeModelField;
-	path: [
-		PathElement<CustomTypeModel | SharedSliceModel>,
-		...PathElement<CustomTypeModelField | CustomTypeModelSlice>[],
-	];
-	tabName?: string;
+import { getHumanReadablePath } from "./getHumanReadablePath";
+
+type GetFieldHumanReadableTypeArgs = {
+	field: CustomTypeModelField;
 };
 
-export const buildFieldDocs = (
-	config: BuildFieldDocsConfig,
-): NonNullable<JSDocableNodeStructure["docs"]> => {
-	return [
-		{
-			description: (writer) => {
-				const name = getHumanReadableModelName({
-					id: config.id,
-					model: config.model,
-				});
-				const humanReadablePath = getHumanReadableFieldPath({
-					path: config.path,
-				});
-
-				const fieldType = getHumanReadableFieldType({
-					model: config.model,
-				});
-
-				const placeholder =
-					config.model.config &&
-					"placeholder" in config.model.config &&
-					config.model.config.placeholder
-						? config.model.config.placeholder
-						: `*None*`;
-
-				const defaultValue =
-					config.model.config && "default_value" in config.model.config
-						? config.model.config.default_value
-						: undefined;
-
-				const apiIDPath = getAPIIDPath({
-					path: [...config.path, { id: config.id, model: config.model }],
-				});
-
-				writeFieldDocsDescription({
-					writer,
-					description: `${name} field in *${humanReadablePath}*`,
-					fieldType,
-					placeholder,
-					defaultValue,
-					apiIDPath,
-					tabName: config.tabName,
-					documentationURL: getFieldDocumentationURL({ model: config.model }),
-				});
-			},
-		},
-	];
+function getHumanReadableFieldType(
+	args: GetFieldHumanReadableTypeArgs,
+): string {
+	switch (args.field.type) {
+		case "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));
+
+			return isTitleField ? "Title" : "Rich Text";
+		}
+
+		case "IntegrationFields": {
+			const catalog = args.field.config?.catalog;
+
+			return `Integration Fields (Catalog: ${
+				catalog ? `\`${catalog}\`` : "*unknown*"
+			})`;
+		}
+
+		case "Link": {
+			switch (args.field.config?.select) {
+				case "document": {
+					return "Content Relationship";
+				}
+
+				case "media": {
+					return "Link to Media";
+				}
+
+				default: {
+					return "Link";
+				}
+			}
+		}
+
+		case "Slices": {
+			return "Slice Zone";
+		}
+
+		default: {
+			return args.field.type;
+		}
+	}
+}
+
+type BuildFieldDocsArgs = {
+	name: string;
+	field: CustomTypeModelField;
+	path: FieldPath;
+	tabName?: string;
 };
+
+export function buildFieldDocs(args: BuildFieldDocsArgs): string {
+	let result = "/**";
+
+	const humanReadableName = getHumanReadableModelName({
+		model: args.field,
+		name: args.name,
+	});
+	const humanReadablePath = getHumanReadablePath({ path: args.path });
+	const humanReadableFieldType = getHumanReadableFieldType({
+		field: args.field,
+	});
+
+	result = addLine(
+		` * ${humanReadableName} field in *${humanReadablePath}*`,
+		result,
+	);
+
+	result = addLine(" *", result);
+
+	result = addLine(` * - **Field Type**: ${humanReadableFieldType}`, result);
+
+	const placeholder =
+		(args.field.config &&
+			"placeholder" in args.field.config &&
+			args.field.config.placeholder) ||
+		`*None*`;
+	result = addLine(` * - **Placeholder**: ${placeholder}`, result);
+
+	const defaultValue =
+		args.field.config && "default_value" in args.field.config
+			? args.field.config.default_value
+			: undefined;
+	if (defaultValue !== undefined) {
+		const stringifiedDefaultValue =
+			typeof defaultValue === "boolean" ? `${defaultValue}` : defaultValue;
+
+		result = addLine(
+			` * - **Default Value**: ${stringifiedDefaultValue}`,
+			result,
+		);
+	}
+
+	const apiIDPath = getAPIIDPath({
+		path: [...args.path, { name: args.name, model: args.field }],
+	});
+	result = addLine(` * - **API ID Path**: ${apiIDPath}`, result);
+
+	if (args.tabName) {
+		result = addLine(` * - **Tab**: ${args.tabName}`, result);
+	}
+
+	const documentationURL =
+		FIELD_DOCUMENTATION_URLS[
+			args.field.type as keyof typeof FIELD_DOCUMENTATION_URLS
+		];
+	if (documentationURL) {
+		result = addLine(` * - **Documentation**: ${documentationURL}`, result);
+	}
+
+	result = addLine(" */", result);
+
+	return result;
+}

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,
+	};
+}