prismic-ts-codegen 0.0.2

package/src/lib/addTypeAliasForCustomType.ts

@@ -0,0 +1,110 @@
+import type { CustomTypeModel, CustomTypeModelField } from "@prismicio/types";
+import type {
+	SourceFile,
+	TypeAliasDeclaration,
+	InterfaceDeclaration,
+} from "ts-morph";
+import { CUSTOM_TYPES_DOCUMENTATION_URL } from "../constants";
+import { FieldConfigs } from "../types";
+
+import { addInterfacePropertiesForFields } from "./addInterfacePropertiesForFields";
+import { pascalCase } from "./pascalCase";
+
+const collectCustomTypeFields = (
+	model: CustomTypeModel,
+): Record<string, CustomTypeModelField> => {
+	return Object.assign({}, ...Object.values(model.json));
+};
+
+type AddTypeAliasForCustomTypeConfig = {
+	model: CustomTypeModel;
+	sourceFile: SourceFile;
+	localeIDs: string[];
+	fieldConfigs: FieldConfigs;
+};
+
+export const addTypeAliasForCustomType = ({
+	model,
+	sourceFile,
+	localeIDs,
+	fieldConfigs,
+}: AddTypeAliasForCustomTypeConfig): TypeAliasDeclaration => {
+	const { uid: uidField, ...fields } = collectCustomTypeFields(model);
+	const hasDataFields = Object.keys(fields).length > 0;
+	const hasUIDField = Boolean(uidField);
+
+	let dataInterface: InterfaceDeclaration | TypeAliasDeclaration;
+	if (hasDataFields) {
+		dataInterface = sourceFile.addInterface({
+			name: pascalCase(`${model.id} Document Data`),
+			docs: [
+				{
+					description: `Content for ${model.label} documents`,
+				},
+			],
+		});
+		addInterfacePropertiesForFields({
+			fields,
+			interface: dataInterface,
+			sourceFile: sourceFile,
+			path: [
+				{
+					id: model.id,
+					model: model,
+				},
+			],
+			fieldConfigs,
+		});
+	} else {
+		dataInterface = sourceFile.addTypeAlias({
+			name: pascalCase(`${model.id} Document Data`),
+			type: `Record<string, never>`,
+			docs: [
+				{
+					description: `Content for ${model.label} documents`,
+				},
+			],
+		});
+	}
+
+	return sourceFile.addTypeAlias({
+		name: pascalCase(`${model.id} Document`),
+		typeParameters: [
+			{
+				name: "Lang",
+				constraint: "string",
+				default:
+					localeIDs.length > 0
+						? localeIDs.map((localeID) => `"${localeID}"`).join(" | ")
+						: "string",
+			},
+		],
+		type: hasUIDField
+			? `prismicT.PrismicDocumentWithUID<Simplify<${dataInterface.getName()}>, "${
+					model.id
+			  }", Lang>`
+			: `prismicT.PrismicDocumentWithoutUID<Simplify<${dataInterface.getName()}>, "${
+					model.id
+			  }", Lang>`,
+		docs: [
+			{
+				description: (writer) => {
+					writer.writeLine(`${model.label} document from Prismic`);
+					writer.blankLine();
+					writer.writeLine(`- **API ID**: \`${model.id}\``);
+					writer.writeLine(`- **Repeatable**: \`${model.repeatable}\``);
+					writer.writeLine(
+						`- **Documentation**: ${CUSTOM_TYPES_DOCUMENTATION_URL}`,
+					);
+				},
+				tags: [
+					{
+						tagName: "typeParam",
+						text: "Lang - Language API ID of the document.",
+					},
+				],
+			},
+		],
+		isExported: true,
+	});
+};

package/src/lib/addTypeAliasForSharedSlice.ts

@@ -0,0 +1,200 @@
+import type { SharedSliceModel } from "@prismicio/types";
+import type {
+	InterfaceDeclaration,
+	SourceFile,
+	TypeAliasDeclaration,
+} from "ts-morph";
+
+import { addInterfacePropertiesForFields } from "./addInterfacePropertiesForFields";
+import { buildSharedSliceInterfaceName } from "./buildSharedSliceInterfaceName";
+import { pascalCase } from "./pascalCase";
+import { getHumanReadableFieldPath } from "./getHumanReadableFieldPath";
+import { SHARED_SLICES_DOCUMENTATION_URL } from "../constants";
+import { FieldConfigs } from "../types";
+
+type AddTypeAliasForSharedSliceConfig = {
+	model: SharedSliceModel;
+	sourceFile: SourceFile;
+	fieldConfigs: FieldConfigs;
+};
+
+export const addTypeAliasForSharedSlice = (
+	config: AddTypeAliasForSharedSliceConfig,
+): TypeAliasDeclaration => {
+	const variationTypeNames: string[] = [];
+
+	for (const variation of config.model.variations) {
+		let primaryInterface: InterfaceDeclaration | undefined;
+		if (Object.keys(variation.primary).length > 0) {
+			primaryInterface = config.sourceFile.addInterface({
+				name: pascalCase(
+					`${buildSharedSliceInterfaceName({ id: config.model.id })} ${
+						variation.id
+					} Primary`,
+				),
+				docs: [
+					{
+						description: (writer) => {
+							const humanReadablePath = getHumanReadableFieldPath({
+								path: [
+									{
+										id: config.model.id,
+										model: config.model,
+									},
+									{
+										id: "primary",
+										label: "Primary",
+									},
+								],
+							});
+
+							writer.writeLine(`Primary content in ${humanReadablePath}`);
+						},
+					},
+				],
+			});
+			addInterfacePropertiesForFields({
+				interface: primaryInterface,
+				sourceFile: config.sourceFile,
+				fields: variation.primary,
+				path: [
+					{
+						id: config.model.id,
+						model: config.model,
+					},
+					{
+						id: "primary",
+						label: "Primary",
+					},
+				],
+				fieldConfigs: config.fieldConfigs,
+			});
+		}
+
+		let itemInterface: InterfaceDeclaration | undefined;
+		if (Object.keys(variation.items).length > 0) {
+			itemInterface = config.sourceFile.addInterface({
+				name: pascalCase(
+					`${buildSharedSliceInterfaceName({ id: config.model.id })} ${
+						variation.id
+					} Item`,
+				),
+				docs: [
+					{
+						description: (writer) => {
+							const humanReadablePath = getHumanReadableFieldPath({
+								path: [
+									{
+										id: config.model.id,
+										model: config.model,
+									},
+									{
+										id: "items",
+										label: "Items",
+									},
+								],
+							});
+
+							writer.writeLine(`Item in ${humanReadablePath}`);
+						},
+					},
+				],
+			});
+			addInterfacePropertiesForFields({
+				interface: itemInterface,
+				sourceFile: config.sourceFile,
+				fields: variation.items,
+				path: [
+					{
+						id: config.model.id,
+						model: config.model,
+					},
+					{
+						id: "items",
+						label: "Items",
+					},
+				],
+				fieldConfigs: config.fieldConfigs,
+			});
+		}
+
+		const variationType = config.sourceFile.addTypeAlias({
+			name: pascalCase(
+				`${buildSharedSliceInterfaceName({
+					id: config.model.id,
+				})} ${variation.id}`,
+			),
+			type: `prismicT.SharedSliceVariation<"${variation.id}", ${
+				primaryInterface
+					? `Simplify<${primaryInterface.getName()}>`
+					: "Record<string, never>"
+			}, ${itemInterface ? `Simplify<${itemInterface.getName()}>` : "never"}>`,
+			docs: [
+				{
+					description: (writer) => {
+						writer.writeLine(
+							`${variation.name} variation for ${config.model.name} Slice`,
+						);
+						writer.blankLine();
+						writer.writeLine(`- **API ID**: \`${variation.id}\``);
+						writer.writeLine(`- **Description**: \`${variation.description}\``);
+						writer.writeLine(
+							`- **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}`,
+						);
+					},
+				},
+			],
+		});
+
+		variationTypeNames.push(variationType.getName());
+	}
+
+	const variationsType = config.sourceFile.addTypeAlias({
+		name: pascalCase(`${config.model.id} Slice Variation`),
+		type:
+			variationTypeNames.length > 0 ? variationTypeNames.join(" | ") : "never",
+		docs: [
+			{
+				description: (writer) => {
+					const humanReadablePath = getHumanReadableFieldPath({
+						path: [
+							{
+								id: config.model.id,
+								model: config.model,
+							},
+						],
+					});
+
+					writer.writeLine(`Slice variation for *${humanReadablePath}*`);
+				},
+			},
+		],
+	});
+
+	return config.sourceFile.addTypeAlias({
+		name: pascalCase(
+			buildSharedSliceInterfaceName({
+				id: config.model.id,
+			}),
+		),
+		type: `prismicT.SharedSlice<"${
+			config.model.id
+		}", ${variationsType.getName()}>`,
+		docs: [
+			{
+				description: (writer) => {
+					writer.writeLine(`${config.model.name} Shared Slice`);
+					writer.blankLine();
+					writer.writeLine(`- **API ID**: \`${config.model.id}\``);
+					writer.writeLine(
+						`- **Description**: \`${config.model.description}\``,
+					);
+					writer.writeLine(
+						`- **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}`,
+					);
+				},
+			},
+		],
+		isExported: true,
+	});
+};

package/src/lib/buildFieldDocs.ts

@@ -0,0 +1,71 @@
+import type {
+	CustomTypeModel,
+	CustomTypeModelField,
+	CustomTypeModelSlice,
+	SharedSliceModel,
+} from "@prismicio/types";
+import type { JSDocableNodeStructure } from "ts-morph";
+
+import { PathElement } from "../types";
+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>[]
+	];
+};
+
+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 =
+					"placeholder" in config.model.config &&
+					config.model.config.placeholder
+						? config.model.config.placeholder
+						: `*None*`;
+
+				const defaultValue =
+					"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,
+					documentationURL: getFieldDocumentationURL({ model: config.model }),
+				});
+			},
+		},
+	];
+};

package/src/lib/buildSharedSliceInterfaceName.ts

@@ -0,0 +1,11 @@
+import { pascalCase } from "./pascalCase";
+
+type BuildSharedSliceInterfaceNameConfig = {
+	id: string;
+};
+
+export const buildSharedSliceInterfaceName = (
+	config: BuildSharedSliceInterfaceNameConfig,
+): string => {
+	return pascalCase(`${config.id} Slice`);
+};

package/src/lib/getAPIIDPath.ts

@@ -0,0 +1,46 @@
+import type {
+	CustomTypeModel,
+	CustomTypeModelField,
+	CustomTypeModelSlice,
+	SharedSliceModel,
+} from "@prismicio/types";
+import { CustomTypeModelFieldType } from "@prismicio/types";
+
+import { PathElement } from "../types";
+import { isCustomTypeModelField } from "./isCustomTypeModelField";
+import { isCustomTypeModelSlice } from "./isCustomTypeModelSlice";
+import { isSharedSliceModel } from "./isSharedSliceModel";
+
+type GetAPIIDPathConfig = {
+	path: [
+		PathElement<CustomTypeModel | SharedSliceModel>,
+		...PathElement<CustomTypeModelField | CustomTypeModelSlice>[]
+	];
+};
+
+export const getAPIIDPath = (config: GetAPIIDPathConfig): string => {
+	return config.path
+		.map((element, i) => {
+			if (
+				isCustomTypeModelField(element.model) &&
+				(element.model.type === CustomTypeModelFieldType.Group ||
+					element.model.type === CustomTypeModelFieldType.Slices)
+			) {
+				return `${element.id}[]`;
+			} else {
+				if (element.id === "items") {
+					const previousElement = config.path[i - 1];
+
+					if (
+						isCustomTypeModelSlice(previousElement.model) ||
+						isSharedSliceModel(previousElement.model)
+					) {
+						return `${element.id}[]`;
+					}
+				}
+
+				return element.id;
+			}
+		})
+		.join(".");
+};

package/src/lib/getFieldDocumentationURL.ts

@@ -0,0 +1,13 @@
+import type { CustomTypeModelField } from "@prismicio/types";
+
+import { FIELD_DOCUMENTATION_URLS } from "../constants";
+
+type GetFieldDocumentationURLConfig = {
+	model: CustomTypeModelField;
+};
+
+export const getFieldDocumentationURL = (
+	config: GetFieldDocumentationURLConfig,
+): string => {
+	return FIELD_DOCUMENTATION_URLS[config.model.type];
+};

package/src/lib/getHumanReadableFieldPath.ts

@@ -0,0 +1,35 @@
+import type {
+	CustomTypeModel,
+	CustomTypeModelField,
+	CustomTypeModelSlice,
+	SharedSliceModel,
+} from "@prismicio/types";
+
+import { PathElement } from "../types";
+import { getHumanReadableModelName } from "./getHumanReadableModelName";
+
+type GetHumanReadableFieldPathConfig = {
+	path: [
+		PathElement<CustomTypeModel | SharedSliceModel>,
+		...PathElement<CustomTypeModelField | CustomTypeModelSlice>[]
+	];
+};
+
+export const getHumanReadableFieldPath = (
+	config: GetHumanReadableFieldPathConfig,
+): string => {
+	return config.path
+		.map((element) => {
+			if (element.label) {
+				return element.label;
+			} else if (element.model) {
+				return getHumanReadableModelName({
+					id: element.id,
+					model: element.model,
+				});
+			} else {
+				return element.id;
+			}
+		})
+		.join(" → ");
+};

package/src/lib/getHumanReadableFieldType.ts

@@ -0,0 +1,50 @@
+import type { CustomTypeModelField } from "@prismicio/types";
+import { CustomTypeModelLinkSelectType } from "@prismicio/types";
+
+type GetFieldHumanReadableTypeConfig = {
+	model: CustomTypeModelField;
+};
+
+export const getHumanReadableFieldType = (
+	config: GetFieldHumanReadableTypeConfig,
+): string => {
+	switch (config.model.type) {
+		case "StructuredText": {
+			const isTitleField =
+				"single" in config.model.config &&
+				config.model.config.single
+					.split(",")
+					.every((blockType) => /heading/.test(blockType));
+
+			return isTitleField ? "Title" : "Rich Text";
+		}
+
+		case "IntegrationFields": {
+			return `Integration Fields (Catalog: \`${config.model.config.catalog}\`)`;
+		}
+
+		case "Link": {
+			switch (config.model.config.select) {
+				case CustomTypeModelLinkSelectType.Document: {
+					return "Content Relationship";
+				}
+
+				case CustomTypeModelLinkSelectType.Media: {
+					return "Link to Media";
+				}
+
+				default: {
+					return "Link";
+				}
+			}
+		}
+
+		case "Slices": {
+			return "Slice Zone";
+		}
+
+		default: {
+			return config.model.type;
+		}
+	}
+};

package/src/lib/getHumanReadableModelName.ts

@@ -0,0 +1,40 @@
+import type {
+	CustomTypeModel,
+	CustomTypeModelField,
+	CustomTypeModelSlice,
+	SharedSliceModel,
+} from "@prismicio/types";
+
+import { isCustomTypeModel } from "./isCustomTypeModel";
+import { isCustomTypeModelField } from "./isCustomTypeModelField";
+import { isCustomTypeModelSlice } from "./isCustomTypeModelSlice";
+import { isSharedSliceModel } from "./isSharedSliceModel";
+
+type GetModelHumanNameConfig = {
+	id: string;
+	model:
+		| CustomTypeModel
+		| SharedSliceModel
+		| CustomTypeModelField
+		| CustomTypeModelSlice;
+};
+
+export const getHumanReadableModelName = (
+	config: GetModelHumanNameConfig,
+): string => {
+	if (isCustomTypeModel(config.model)) {
+		return config.model.label;
+	} else if (isSharedSliceModel(config.model)) {
+		return config.model.name;
+	} else if (
+		isCustomTypeModelField(config.model) &&
+		"label" in config.model.config
+	) {
+		return config.model.config.label;
+	} else if (isCustomTypeModelSlice(config.model)) {
+		return config.model.fieldset;
+	} else {
+		// Slice Zone
+		return `Slice Zone (\`${config.id}\`)`;
+	}
+};

package/src/lib/getSourceFileText.ts

@@ -0,0 +1,14 @@
+import * as tsm from "ts-morph";
+// import prettier from "prettier";
+
+import { BLANK_LINE_IDENTIFIER } from "../constants";
+
+export const getSourceFileText = (sourceFile: tsm.SourceFile): string => {
+	const text = sourceFile
+		.print()
+		.replace(new RegExp(BLANK_LINE_IDENTIFIER, "g"), "");
+
+	return text;
+
+	// return prettier.format(text, { parser: "typescript" });
+};

package/src/lib/isCustomTypeModel.ts

@@ -0,0 +1,5 @@
+import type { CustomTypeModel } from "@prismicio/types";
+
+export const isCustomTypeModel = (model: unknown): model is CustomTypeModel => {
+	return typeof model === "object" && model !== null && "json" in model;
+};

package/src/lib/isCustomTypeModelField.ts

@@ -0,0 +1,12 @@
+import type { CustomTypeModelField } from "@prismicio/types";
+
+export const isCustomTypeModelField = (
+	model: unknown,
+): model is CustomTypeModelField => {
+	return (
+		typeof model === "object" &&
+		model !== null &&
+		"type" in model &&
+		"config" in model
+	);
+};

package/src/lib/isCustomTypeModelSlice.ts

@@ -0,0 +1,12 @@
+import type { CustomTypeModelSlice } from "@prismicio/types";
+
+export const isCustomTypeModelSlice = (
+	model: unknown,
+): model is CustomTypeModelSlice => {
+	return (
+		typeof model === "object" &&
+		model !== null &&
+		"non-repeat" in model &&
+		"repeat" in model
+	);
+};

package/src/lib/isSharedSliceModel.ts

@@ -0,0 +1,7 @@
+import type { SharedSliceModel } from "@prismicio/types";
+
+export const isSharedSliceModel = (
+	model: unknown,
+): model is SharedSliceModel => {
+	return typeof model === "object" && model !== null && "variations" in model;
+};

package/src/lib/pascalCase.ts

@@ -0,0 +1,9 @@
+import {
+	pascalCase as pascalCaseBase,
+	pascalCaseTransformMerge,
+} from "pascal-case";
+
+export const pascalCase = (input: string): string =>
+	pascalCaseBase(input, {
+		transform: pascalCaseTransformMerge,
+	});

package/src/lib/writeFieldDocsDescription.ts

@@ -0,0 +1,46 @@
+import type { CodeBlockWriter } from "ts-morph";
+
+type BuildFieldDocsConfig = {
+	writer: CodeBlockWriter;
+	description?: string;
+	fieldType?: string;
+	defaultValue?: string | boolean;
+	placeholder?: string;
+	apiIDPath?: string;
+	documentationURL?: string;
+};
+
+export const writeFieldDocsDescription = (
+	config: BuildFieldDocsConfig,
+): void => {
+	if (config.description) {
+		config.writer.writeLine(config.description);
+	}
+
+	config.writer.blankLineIfLastNot();
+
+	if (config.fieldType) {
+		config.writer.writeLine(`- **Field Type**: ${config.fieldType}`);
+	}
+
+	if (config.placeholder) {
+		config.writer.writeLine(`- **Placeholder**: ${config.placeholder}`);
+	}
+
+	if (config.defaultValue !== undefined) {
+		const stringifiedDefaultValue =
+			typeof config.defaultValue === "boolean"
+				? `${config.defaultValue}`
+				: config.defaultValue;
+
+		config.writer.writeLine(`- **Default Value**: ${stringifiedDefaultValue}`);
+	}
+
+	if (config.apiIDPath) {
+		config.writer.writeLine(`- **API ID Path**: ${config.apiIDPath}`);
+	}
+
+	if (config.documentationURL) {
+		config.writer.writeLine(`- **Documentation**: ${config.documentationURL}`);
+	}
+};