prismic-ts-codegen 0.0.2

package/src/generateTypes.ts

@@ -0,0 +1,65 @@
+import { Project } from "ts-morph";
+import type { CustomTypeModel, SharedSliceModel } from "@prismicio/types";
+
+import { BLANK_LINE_IDENTIFIER, NON_EDITABLE_FILE_HEADER } from "./constants";
+import { addTypeAliasForCustomType } from "./lib/addTypeAliasForCustomType";
+import { addTypeAliasForSharedSlice } from "./lib/addTypeAliasForSharedSlice";
+import { getSourceFileText } from "./lib/getSourceFileText";
+import { FieldConfigs } from "./types";
+
+export type GenerateTypesConfig = {
+	customTypeModels?: CustomTypeModel[];
+	sharedSliceModels?: SharedSliceModel[];
+	localeIDs?: string[];
+	fieldConfigs?: FieldConfigs;
+};
+
+export const generateTypes = (config: GenerateTypesConfig = {}) => {
+	const project = new Project({
+		useInMemoryFileSystem: true,
+	});
+
+	const sourceFile = project.createSourceFile("types.d.ts");
+
+	sourceFile.addImportDeclaration({
+		moduleSpecifier: "@prismicio/types",
+		namespaceImport: "prismicT",
+		isTypeOnly: true,
+		leadingTrivia: NON_EDITABLE_FILE_HEADER,
+	});
+
+	sourceFile.addStatements(BLANK_LINE_IDENTIFIER);
+
+	sourceFile.addTypeAlias({
+		name: "Simplify",
+		typeParameters: [
+			{
+				name: "T",
+			},
+		],
+		type: `{ [KeyType in keyof T]: T[KeyType] }`,
+	});
+
+	if (config.customTypeModels) {
+		for (const model of config.customTypeModels) {
+			addTypeAliasForCustomType({
+				model,
+				sourceFile,
+				localeIDs: config.localeIDs || [],
+				fieldConfigs: config.fieldConfigs || {},
+			});
+		}
+	}
+
+	if (config.sharedSliceModels) {
+		for (const model of config.sharedSliceModels) {
+			addTypeAliasForSharedSlice({
+				model,
+				sourceFile,
+				fieldConfigs: config.fieldConfigs || {},
+			});
+		}
+	}
+
+	return getSourceFileText(sourceFile);
+};

package/src/index.ts

@@ -0,0 +1,6 @@
+export { generateTypes } from "./generateTypes";
+export type { GenerateTypesConfig } from "./generateTypes";
+
+// The CLI configuration type is exported at the root level for ease of access.
+// It is not used in the the library's code.
+export type { Config } from "./cli/types";

package/src/lib/addInterfacePropertiesForFields.ts

@@ -0,0 +1,595 @@
+import type {
+	CustomTypeModel,
+	CustomTypeModelField,
+	CustomTypeModelSlice,
+	SharedSliceModel,
+} from "@prismicio/types";
+import {
+	CustomTypeModelSliceType,
+	CustomTypeModelLinkSelectType,
+} from "@prismicio/types";
+import type { InterfaceDeclaration, SourceFile } from "ts-morph";
+
+import { FieldConfigs, PathElement } from "../types";
+import { buildFieldDocs } from "./buildFieldDocs";
+import { buildSharedSliceInterfaceName } from "./buildSharedSliceInterfaceName";
+import { getHumanReadableFieldPath } from "./getHumanReadableFieldPath";
+import { pascalCase } from "./pascalCase";
+
+type AddInterfacePropertyFromFieldConfig = {
+	id: string;
+	model: CustomTypeModelField;
+	interface: InterfaceDeclaration;
+	sourceFile: SourceFile;
+	path: [
+		PathElement<CustomTypeModel | SharedSliceModel>,
+		...PathElement<CustomTypeModelField | CustomTypeModelSlice>[]
+	];
+	fieldConfigs: FieldConfigs;
+};
+
+const addInterfacePropertyFromField = (
+	config: AddInterfacePropertyFromFieldConfig,
+) => {
+	switch (config.model.type) {
+		case "UID": {
+			// UID fields are not included in Data.
+			break;
+		}
+
+		case "Boolean": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.BooleanField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Color": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.ColorField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Date": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.DateField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Embed": {
+			const providerTypes: string[] = [];
+
+			if (config.fieldConfigs.embed?.providerTypes) {
+				for (const providerType in config.fieldConfigs.embed?.providerTypes) {
+					const configuredProviderType =
+						config.fieldConfigs.embed?.providerTypes[providerType];
+
+					providerTypes.push(
+						`({ provider_name: "${providerType}" } & ${configuredProviderType})`,
+					);
+				}
+			}
+
+			config.interface.addProperty({
+				name: config.id,
+				type:
+					providerTypes.length > 0
+						? `prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra & (${providerTypes.join(
+								" | ",
+						  )})>`
+						: "prismicT.EmbedField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "GeoPoint": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.GeoPointField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Image": {
+			if (config.model.config.thumbnails.length > 0) {
+				const thumbnailNames = config.model.config.thumbnails
+					.map((thumbnail) => `"${thumbnail.name}"`)
+					.join(" | ");
+
+				config.interface.addProperty({
+					name: config.id,
+					type: `prismicT.ImageField<${thumbnailNames}>`,
+					docs: buildFieldDocs({
+						id: config.id,
+						model: config.model,
+						path: config.path,
+					}),
+				});
+			} else {
+				config.interface.addProperty({
+					name: config.id,
+					type: "prismicT.ImageField<null>",
+					docs: buildFieldDocs({
+						id: config.id,
+						model: config.model,
+						path: config.path,
+					}),
+				});
+			}
+
+			break;
+		}
+
+		case "IntegrationFields": {
+			const catalogType =
+				config.fieldConfigs.integrationFields?.catalogTypes?.[
+					config.model.config.catalog
+				];
+
+			config.interface.addProperty({
+				name: config.id,
+				type: catalogType
+					? `prismicT.IntegrationFields<${catalogType}>`
+					: "prismicT.IntegrationFields",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Link": {
+			switch (config.model.config.select) {
+				case CustomTypeModelLinkSelectType.Document: {
+					config.interface.addProperty({
+						name: config.id,
+						type:
+							config.model.config.customtypes &&
+							config.model.config.customtypes.length > 0
+								? `prismicT.RelationField<${config.model.config.customtypes
+										.map((type) => `"${type}"`)
+										.join(" | ")}>`
+								: "prismicT.RelationField",
+						docs: buildFieldDocs({
+							id: config.id,
+							model: config.model,
+							path: config.path,
+						}),
+					});
+
+					break;
+				}
+
+				case CustomTypeModelLinkSelectType.Media: {
+					config.interface.addProperty({
+						name: config.id,
+						type: "prismicT.LinkToMediaField",
+						docs: buildFieldDocs({
+							id: config.id,
+							model: config.model,
+							path: config.path,
+						}),
+					});
+
+					break;
+				}
+
+				default: {
+					config.interface.addProperty({
+						name: config.id,
+						type: "prismicT.LinkField",
+						docs: buildFieldDocs({
+							id: config.id,
+							model: config.model,
+							path: config.path,
+						}),
+					});
+				}
+			}
+
+			break;
+		}
+
+		case "Number": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.NumberField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "StructuredText": {
+			const isTitleField =
+				"single" in config.model.config &&
+				config.model.config.single
+					.split(",")
+					.every((blockType) => /heading/.test(blockType));
+
+			if (isTitleField) {
+				config.interface.addProperty({
+					name: config.id,
+					type: "prismicT.TitleField",
+					docs: buildFieldDocs({
+						id: config.id,
+						model: config.model,
+						path: config.path,
+					}),
+				});
+			} else {
+				config.interface.addProperty({
+					name: config.id,
+					type: "prismicT.RichTextField",
+					docs: buildFieldDocs({
+						id: config.id,
+						model: config.model,
+						path: config.path,
+					}),
+				});
+			}
+
+			break;
+		}
+
+		case "Select": {
+			const options = config.model.config.options
+				.map((option) => `"${option}"`)
+				.join(" | ");
+			const hasDefault = Boolean(config.model.config.default_value);
+
+			if (hasDefault) {
+				config.interface.addProperty({
+					name: config.id,
+					type: `prismicT.SelectField<${options}, "filled">`,
+					docs: buildFieldDocs({
+						id: config.id,
+						model: config.model,
+						path: config.path,
+					}),
+				});
+			} else {
+				config.interface.addProperty({
+					name: config.id,
+					type: `prismicT.SelectField<${options}>`,
+					docs: buildFieldDocs({
+						id: config.id,
+						model: config.model,
+						path: config.path,
+					}),
+				});
+			}
+
+			break;
+		}
+
+		case "Text": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.KeyTextField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Timestamp": {
+			config.interface.addProperty({
+				name: config.id,
+				type: "prismicT.TimestampField",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Group": {
+			const itemInterface = config.sourceFile.addInterface({
+				name: pascalCase(
+					`${config.path[0].id} Document Data ${config.id} Item`,
+				),
+				docs: [
+					{
+						description: (writer) => {
+							const humanReadablePath = getHumanReadableFieldPath({
+								path: [
+									...config.path,
+									{
+										id: config.id,
+										model: config.model,
+									},
+								],
+							});
+
+							writer.writeLine(`Item in ${humanReadablePath}`);
+						},
+					},
+				],
+			});
+			addInterfacePropertiesForFields({
+				interface: itemInterface,
+				sourceFile: config.sourceFile,
+				fields: config.model.config.fields,
+				path: [
+					...config.path,
+					{
+						id: config.id,
+						model: config.model,
+					},
+				],
+				fieldConfigs: config.fieldConfigs,
+			});
+
+			config.interface.addProperty({
+				name: config.id,
+				type: `prismicT.GroupField<Simplify<${itemInterface.getName()}>>`,
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		case "Slices": {
+			const choiceInterfaceNames: string[] = [];
+
+			for (const choiceId in config.model.config.choices) {
+				const choice = config.model.config.choices[choiceId];
+
+				if (choice.type === CustomTypeModelSliceType.SharedSlice) {
+					choiceInterfaceNames.push(
+						buildSharedSliceInterfaceName({ id: choiceId }),
+					);
+				} else if (choice.type === CustomTypeModelSliceType.Slice) {
+					let primaryInterface: InterfaceDeclaration | undefined;
+					if (Object.keys(choice["non-repeat"]).length > 0) {
+						primaryInterface = config.sourceFile.addInterface({
+							name: pascalCase(
+								`${config.path[0].id} Document Data ${config.id} ${choiceId} Slice Primary`,
+							),
+							docs: [
+								{
+									description: (writer) => {
+										const humanReadablePath = getHumanReadableFieldPath({
+											path: [
+												...config.path,
+												{
+													id: config.id,
+													model: config.model,
+												},
+												{
+													id: choiceId,
+													model: choice,
+												},
+												{
+													id: "primary",
+													label: "Primary",
+												},
+											],
+										});
+
+										writer.writeLine(`Primary content in ${humanReadablePath}`);
+									},
+								},
+							],
+						});
+						addInterfacePropertiesForFields({
+							interface: primaryInterface,
+							sourceFile: config.sourceFile,
+							fields: choice["non-repeat"],
+							path: [
+								...config.path,
+								{
+									id: config.id,
+									model: config.model,
+								},
+								{
+									id: choiceId,
+									model: choice,
+								},
+								{
+									id: "primary",
+									label: "Primary",
+								},
+							],
+							fieldConfigs: config.fieldConfigs,
+						});
+					}
+
+					let itemInterface: InterfaceDeclaration | undefined;
+					if (Object.keys(choice.repeat).length > 0) {
+						itemInterface = config.sourceFile.addInterface({
+							name: pascalCase(
+								`${config.path[0].id} Document Data ${config.id} ${choiceId} Slice Item`,
+							),
+							docs: [
+								{
+									description: (writer) => {
+										const humanReadablePath = getHumanReadableFieldPath({
+											path: [
+												...config.path,
+												{
+													id: config.id,
+													model: config.model,
+												},
+												{
+													id: choiceId,
+													model: choice,
+												},
+												{
+													id: "items",
+													label: "Items",
+												},
+											],
+										});
+
+										writer.writeLine(`Item in ${humanReadablePath}`);
+									},
+								},
+							],
+						});
+						addInterfacePropertiesForFields({
+							interface: itemInterface,
+							sourceFile: config.sourceFile,
+							fields: choice.repeat,
+							path: [
+								...config.path,
+								{
+									id: config.id,
+									model: config.model,
+								},
+								{
+									id: choiceId,
+									model: choice,
+								},
+								{
+									id: "items",
+									label: "Items",
+								},
+							],
+							fieldConfigs: config.fieldConfigs,
+						});
+					}
+
+					const sliceType = config.sourceFile.addTypeAlias({
+						name: pascalCase(
+							`${config.path[0].id} Document Data ${config.id} ${choiceId} Slice`,
+						),
+						type: `prismicT.Slice<"${choiceId}", ${
+							primaryInterface
+								? `Simplify<${primaryInterface.getName()}>`
+								: "Record<string, never>"
+						}, ${
+							itemInterface ? `Simplify<${itemInterface.getName()}>` : "never"
+						}>`,
+					});
+
+					choiceInterfaceNames.push(sliceType.getName());
+				}
+			}
+
+			const slicesType = config.sourceFile.addTypeAlias({
+				name: pascalCase(
+					`${config.path[0].id} Document Data ${config.id} Slice`,
+				),
+				type:
+					choiceInterfaceNames.length > 0
+						? choiceInterfaceNames.join(" | ")
+						: "never",
+				docs: [
+					{
+						description: (writer) => {
+							const humanReadablePath = getHumanReadableFieldPath({
+								path: [
+									...config.path,
+									{
+										id: config.id,
+										model: config.model,
+									},
+								],
+							});
+
+							writer.writeLine(`Slice for *${humanReadablePath}*`);
+						},
+					},
+				],
+			});
+
+			config.interface.addProperty({
+				name: config.id,
+				type: `prismicT.SliceZone<${slicesType.getName()}>`,
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+
+			break;
+		}
+
+		default: {
+			config.interface.addProperty({
+				name: config.id,
+				type: "unknown",
+				docs: buildFieldDocs({
+					id: config.id,
+					model: config.model,
+					path: config.path,
+				}),
+			});
+		}
+	}
+};
+
+type AddInterfacePropertiesForFieldsConfig = Omit<
+	AddInterfacePropertyFromFieldConfig,
+	"id" | "model"
+> & {
+	fields: Record<string, AddInterfacePropertyFromFieldConfig["model"]>;
+};
+
+export const addInterfacePropertiesForFields = (
+	config: AddInterfacePropertiesForFieldsConfig,
+) => {
+	for (const name in config.fields) {
+		addInterfacePropertyFromField({
+			...config,
+			id: name,
+			model: config.fields[name],
+		});
+	}
+};