prismic-ts-codegen 0.1.11 → 0.1.13

package/src/generateTypes.ts

@@ -1,17 +1,19 @@
 import type { CustomTypeModel, SharedSliceModel } from "@prismicio/client";
-import { ModuleDeclarationKind, Project } from "ts-morph";
+import { source } from "common-tags";
+import QuickLRU from "quick-lru";
 
-import { addTypeAliasForCustomType } from "./lib/addTypeAliasForCustomType";
-import { addTypeAliasForSharedSlice } from "./lib/addTypeAliasForSharedSlice";
-import { buildTypeName } from "./lib/buildTypeName";
-import { getSourceFileText } from "./lib/getSourceFileText";
+import { addLine } from "./lib/addLine";
+import { addSection } from "./lib/addSection";
+import { buildCustomTypeType } from "./lib/buildCustomTypeType";
+import { buildSharedSliceType } from "./lib/buildSharedSliceType";
+import { buildUnion } from "./lib/buildUnion";
 
 import { FieldConfigs } from "./types";
 
-import { BLANK_LINE_IDENTIFIER } from "./constants";
-
 export type TypesProvider = "@prismicio/client" | "@prismicio/types";
 
+const cache = new QuickLRU<string, unknown>({ maxSize: 1000 });
+
 export type GenerateTypesConfig = {
 	customTypeModels?: CustomTypeModel[];
 	sharedSliceModels?: SharedSliceModel[];
@@ -22,65 +24,92 @@ export type GenerateTypesConfig = {
 		includeCreateClientInterface?: boolean;
 		includeContentNamespace?: boolean;
 	};
+	cache?: boolean;
 };
 
-export const generateTypes = (config: GenerateTypesConfig = {}) => {
-	const project = new Project({
-		useInMemoryFileSystem: true,
-	});
+export function generateTypes(config: GenerateTypesConfig = {}): string {
+	const fieldConfigs = config.fieldConfigs || {};
+	const shouldUseCache = config.cache ?? true;
 
-	const sourceFile = project.createSourceFile("types.d.ts");
+	let code = "";
 
 	const typesProvider = config.typesProvider || "@prismicio/types";
+	let clientImportName = "prismic";
 
-	sourceFile.addImportDeclaration({
-		moduleSpecifier: typesProvider,
-		namespaceImport: "prismic",
-		isTypeOnly: true,
-	});
+	code = addLine(`import type * as prismic from "${typesProvider}";`, code);
 
-	sourceFile.addStatements(BLANK_LINE_IDENTIFIER);
+	if (
+		config.clientIntegration?.includeCreateClientInterface ||
+		config.clientIntegration?.includeContentNamespace
+	) {
+		if (typesProvider !== "@prismicio/client") {
+			clientImportName = "prismicClient";
 
-	const simplifyTypeAlias = sourceFile.addTypeAlias({
-		name: "Simplify",
-		typeParameters: [
-			{
-				name: "T",
-			},
-		],
-		type: `{ [KeyType in keyof T]: T[KeyType] }`,
-	});
+			// This import declaration would be a duplicate if the types
+			// provider is @prismicio/client.
+			code = addLine(
+				`import type * as ${clientImportName} from "@prismicio/client";`,
+				code,
+			);
+		}
+	}
+
+	code = addSection(
+		`type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };`,
+		code,
+	);
+
+	const contentTypeNames: string[] = [];
 
 	if (config.customTypeModels) {
+		const allDocumentTypesTypeNames: string[] = [];
+
 		for (const model of config.customTypeModels) {
-			addTypeAliasForCustomType({
+			const customTypeType = buildCustomTypeType({
 				model,
-				sourceFile,
-				localeIDs: config.localeIDs || [],
-				fieldConfigs: config.fieldConfigs || {},
+				localeIDs: config.localeIDs,
+				fieldConfigs,
+				cache: shouldUseCache ? cache : undefined,
 			});
+
+			for (const auxiliaryType of customTypeType.auxiliaryTypes) {
+				code = addSection(auxiliaryType.code, code);
+			}
+
+			code = addSection(customTypeType.code, code);
+
+			allDocumentTypesTypeNames.push(customTypeType.name);
+
+			contentTypeNames.push(customTypeType.name);
+			contentTypeNames.push(customTypeType.dataName);
 		}
 
 		if (config.customTypeModels.length > 0) {
-			sourceFile.addTypeAlias({
-				name: "AllDocumentTypes",
-				type: config.customTypeModels
-					.map((customTypeModel) =>
-						buildTypeName(customTypeModel.id, "Document"),
-					)
-					.join(" | "),
-				isExported: true,
-			});
+			const allDocumentTypesUnionName = "AllDocumentTypes";
+			const allDocumentTypesUnion = buildUnion(allDocumentTypesTypeNames);
+
+			code = addSection(
+				`export type ${allDocumentTypesUnionName} = ${allDocumentTypesUnion};`,
+				code,
+			);
+
+			contentTypeNames.push(allDocumentTypesUnionName);
 		}
 	}
 
 	if (config.sharedSliceModels) {
 		for (const model of config.sharedSliceModels) {
-			addTypeAliasForSharedSlice({
+			const sharedSliceType = buildSharedSliceType({
 				model,
-				sourceFile,
-				fieldConfigs: config.fieldConfigs || {},
+				fieldConfigs,
+				cache: shouldUseCache ? cache : undefined,
 			});
+
+			code = addSection(sharedSliceType.code, code);
+
+			contentTypeNames.push(sharedSliceType.name);
+			contentTypeNames.push(sharedSliceType.variationUnionName);
+			contentTypeNames.push(...sharedSliceType.variationNames);
 		}
 	}
 
@@ -88,76 +117,48 @@ export const generateTypes = (config: GenerateTypesConfig = {}) => {
 		config.clientIntegration?.includeCreateClientInterface ||
 		config.clientIntegration?.includeContentNamespace
 	) {
-		let clientNamespaceImportName = "prismic";
-
-		if (typesProvider !== "@prismicio/client") {
-			clientNamespaceImportName = "prismicClient";
-
-			// This import declaration would be a duplicate if the types
-			// provider is @prismicio/client.
-			sourceFile.addImportDeclaration({
-				moduleSpecifier: "@prismicio/client",
-				namespaceImport: clientNamespaceImportName,
-				isTypeOnly: true,
-			});
-		}
-
-		const clientModuleDeclaration = sourceFile.addModule({
-			name: '"@prismicio/client"',
-			hasDeclareKeyword: true,
-			declarationKind: ModuleDeclarationKind.Module,
-		});
+		let clientModuleCode = "";
 
 		if (config.clientIntegration.includeCreateClientInterface) {
-			clientModuleDeclaration.addInterface({
-				name: "CreateClient",
-				callSignatures: [
-					{
-						parameters: [
-							{
-								name: "repositoryNameOrEndpoint",
-								type: "string",
-							},
-							{
-								name: "options",
-								type: `${clientNamespaceImportName}.ClientConfig`,
-								hasQuestionToken: true,
-							},
-						],
-						returnType:
-							(config.customTypeModels?.length || 0) > 0
-								? `${clientNamespaceImportName}.Client<AllDocumentTypes>`
-								: `${clientNamespaceImportName}.Client`,
-					},
-				],
-			});
+			if ((config.customTypeModels?.length || 0) > 0) {
+				clientModuleCode = addSection(
+					`interface CreateClient {
+	(repositoryNameOrEndpoint: string, options?: ${clientImportName}.ClientConfig): ${clientImportName}.Client<AllDocumentTypes>;
+}`,
+					clientModuleCode,
+				);
+			} else {
+				clientModuleCode = addSection(
+					`interface CreateClient {
+	(repositoryNameOrEndpoint: string, options?: ${clientImportName}.ClientConfig): ${clientImportName}.Client;
+}`,
+					clientModuleCode,
+				);
+			}
 		}
 
 		if (config.clientIntegration.includeContentNamespace) {
-			const contentNamespaceDeclaration = clientModuleDeclaration.addModule({
-				name: "Content",
-				declarationKind: ModuleDeclarationKind.Namespace,
-			});
-
-			const exportSymbols = sourceFile
-				.getExportSymbols()
-				.filter((exportSymbol) => {
-					// The Simplify utility type should not
-					// be exported, but it is included in
-					// `getExportSymbols()`'s result.
-					return exportSymbol.getName() !== simplifyTypeAlias.getName();
-				});
-
-			contentNamespaceDeclaration.addExportDeclaration({
-				isTypeOnly: true,
-				namedExports: exportSymbols.map((exportSymbol) => {
-					return {
-						name: exportSymbol.getName(),
-					};
-				}),
-			});
+			clientModuleCode = addSection(
+				source`
+					namespace Content {
+						export type {
+							${contentTypeNames.join(",\n")}
+						}
+					}
+				`,
+				clientModuleCode,
+			);
 		}
+
+		code = addSection(
+			source`
+				declare module "@prismicio/client" {
+					${clientModuleCode}
+				}
+			`,
+			code,
+		);
 	}
 
-	return getSourceFileText(sourceFile);
-};
+	return code;
+}

package/src/lib/addBlankLine.ts

@@ -0,0 +1,13 @@
+import { addTrailingNewLine } from "./addTrailingNewLine";
+
+type AddBlankLineConfig = {
+	force?: boolean;
+};
+
+export function addBlankLine(state: string, config?: AddBlankLineConfig) {
+	if ((!state || state.endsWith("\n\n")) && !config?.force) {
+		return state;
+	} else {
+		return addTrailingNewLine(state) + "\n";
+	}
+}

package/src/lib/addLine.ts

@@ -0,0 +1,5 @@
+import { addTrailingNewLine } from "./addTrailingNewLine";
+
+export function addLine(line: string, state: string) {
+	return addTrailingNewLine(state) + line;
+}

package/src/lib/addSection.ts

@@ -0,0 +1,5 @@
+import { addBlankLine } from "./addBlankLine";
+
+export function addSection(section: string, state: string) {
+	return addBlankLine(state) + section;
+}

package/src/lib/addTrailingNewLine.ts

@@ -0,0 +1,14 @@
+type AddTrailingNewLineConfig = {
+	force?: boolean;
+};
+
+export function addTrailingNewLine(
+	state: string,
+	config?: AddTrailingNewLineConfig,
+) {
+	if ((!state || state.endsWith("\n")) && !config?.force) {
+		return state;
+	} else {
+		return state + "\n";
+	}
+}

package/src/lib/buildCustomTypeDataType.ts

@@ -0,0 +1,74 @@
+import { CustomTypeModel } from "@prismicio/client";
+import { source } from "common-tags";
+
+import { buildTypeName } from "../lib/buildTypeName";
+
+import { AuxiliaryType, FieldConfigs } from "../types";
+
+import { buildFieldProperties } from "./buildFieldProperties";
+import { getHumanReadableModelName } from "./getHumanReadableModelName";
+
+type BuildCustomTypeDataTypeArgs = {
+	model: CustomTypeModel;
+	fieldConfigs: FieldConfigs;
+};
+
+type BuildCustomTypeDataTypeReturnValue = {
+	name: string;
+	code: string;
+	auxiliaryTypes: AuxiliaryType[];
+};
+
+export function buildCustomTypeDataType(
+	args: BuildCustomTypeDataTypeArgs,
+): BuildCustomTypeDataTypeReturnValue {
+	let code = "";
+	const auxiliaryTypes: AuxiliaryType[] = [];
+
+	const name = buildTypeName(args.model.id, "Document", "Data");
+	const humanReadableName = getHumanReadableModelName({
+		name: args.model.id,
+		model: args.model,
+	});
+
+	let fieldProperties = "";
+
+	for (const tabName in args.model.json) {
+		const { uid: _uid, ...fields } = args.model.json[tabName];
+
+		const tabFieldProperties = buildFieldProperties({
+			fields,
+			fieldConfigs: args.fieldConfigs,
+			path: [
+				{
+					name: args.model.id,
+					model: args.model,
+				},
+			],
+			tabName,
+		});
+
+		fieldProperties += tabFieldProperties.code;
+
+		auxiliaryTypes.push(...tabFieldProperties.auxiliaryTypes);
+	}
+
+	if (fieldProperties) {
+		code = source`
+			/**
+			 * Content for ${humanReadableName} documents
+			 */
+			interface ${name} {
+				${fieldProperties}
+			}
+		`;
+	} else {
+		code = `interface ${name} {}`;
+	}
+
+	return {
+		name,
+		code,
+		auxiliaryTypes,
+	};
+}

package/src/lib/buildCustomTypeType.ts

@@ -0,0 +1,101 @@
+import { CustomTypeModel } from "@prismicio/client";
+import { source } from "common-tags";
+import QuickLRU from "quick-lru";
+
+import { AuxiliaryType, FieldConfigs } from "../types";
+
+import { CUSTOM_TYPES_DOCUMENTATION_URL } from "../constants";
+
+import { addSection } from "./addSection";
+import { buildCustomTypeDataType } from "./buildCustomTypeDataType";
+import { buildTypeName } from "./buildTypeName";
+import { buildUnion } from "./buildUnion";
+import { checkHasUIDField } from "./checkHasUIDFIeld";
+import { getCacheKey } from "./getCacheKey";
+import { getHumanReadableModelName } from "./getHumanReadableModelName";
+
+type BuildCustomTypeTypesArgs = {
+	model: CustomTypeModel;
+	localeIDs?: string[];
+	fieldConfigs: FieldConfigs;
+	cache?: QuickLRU<string, unknown>;
+};
+
+type BuildCustomTypeTypeReturnValue = {
+	name: string;
+	dataName: string;
+	code: string;
+	auxiliaryTypes: AuxiliaryType[];
+};
+
+export function buildCustomTypeType(
+	args: BuildCustomTypeTypesArgs,
+): BuildCustomTypeTypeReturnValue {
+	if (args.cache) {
+		const key = getCacheKey(args.model);
+		const cached = args.cache.get(key);
+
+		if (cached) {
+			return cached as BuildCustomTypeTypeReturnValue;
+		}
+	}
+
+	let code = "";
+
+	const auxiliaryTypes: AuxiliaryType[] = [];
+
+	const name = buildTypeName(args.model.id, "Document");
+	const langDefault =
+		args.localeIDs && args.localeIDs.length > 0
+			? buildUnion(args.localeIDs.map((localeID) => `"${localeID}"`))
+			: "string";
+	const baseDocumentType = checkHasUIDField(args.model)
+		? "PrismicDocumentWithUID"
+		: "PrismicDocumentWithoutUID";
+	const humanReadableName = getHumanReadableModelName({
+		name: args.model.id,
+		model: args.model,
+	});
+
+	const dataType = buildCustomTypeDataType({
+		model: args.model,
+		fieldConfigs: args.fieldConfigs,
+	});
+
+	auxiliaryTypes.push(...dataType.auxiliaryTypes);
+
+	code = addSection(dataType.code, code);
+
+	code = addSection(
+		source`
+			/**
+			 * ${humanReadableName} document from Prismic
+			 *
+			 * - **API ID**: \`${args.model.id}\`
+			 * - **Repeatable**: \`${args.model.repeatable.toString()}\`
+			 * - **Documentation**: ${CUSTOM_TYPES_DOCUMENTATION_URL}
+			 *
+			 * @typeParam Lang - Language API ID of the document.
+			 */
+			export type ${name}<Lang extends string = ${langDefault}> = prismic.${baseDocumentType}<Simplify<${
+			dataType.name
+		}>, "${args.model.id}", Lang>;
+		`,
+		code,
+	);
+
+	const result = {
+		name,
+		dataName: dataType.name,
+		code,
+		auxiliaryTypes,
+	};
+
+	if (args.cache) {
+		const key = getCacheKey(args.model);
+
+		args.cache.set(key, result);
+	}
+
+	return result;
+}

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