prismic-ts-codegen 0.1.10 → 0.1.12

package/src/constants.ts

@@ -1,12 +1,9 @@
 import type { CustomTypeModelFieldType } from "@prismicio/client";
 
-export const BLANK_LINE_IDENTIFIER = "// ___BLANK_LINE_TO_BE_REPLACED___";
-
 export const CUSTOM_TYPES_DOCUMENTATION_URL =
-	"https://prismic.io/docs/core-concepts/custom-types";
+	"https://prismic.io/docs/custom-types";
 
-export const SHARED_SLICES_DOCUMENTATION_URL =
-	"https://prismic.io/docs/core-concepts/reusing-slices";
+export const SHARED_SLICES_DOCUMENTATION_URL = "https://prismic.io/docs/slice";
 
 export const FIELD_DOCUMENTATION_URLS: Record<
 	Exclude<
@@ -15,21 +12,21 @@ export const FIELD_DOCUMENTATION_URLS: Record<
 	>,
 	string
 > = {
-	UID: "https://prismic.io/docs/core-concepts/uid",
-	Boolean: "https://prismic.io/docs/core-concepts/boolean",
-	Color: "https://prismic.io/docs/core-concepts/color",
-	Date: "https://prismic.io/docs/core-concepts/date",
-	Timestamp: "https://prismic.io/docs/core-concepts/timestamp",
-	Number: "https://prismic.io/docs/core-concepts/number",
-	Text: "https://prismic.io/docs/core-concepts/key-text",
-	Select: "https://prismic.io/docs/core-concepts/select",
-	StructuredText: "https://prismic.io/docs/core-concepts/rich-text-title",
-	Image: "https://prismic.io/docs/core-concepts/image",
-	Link: "https://prismic.io/docs/core-concepts/link-content-relationship",
-	Embed: "https://prismic.io/docs/core-concepts/embed",
-	GeoPoint: "https://prismic.io/docs/core-concepts/geopoint",
-	Group: "https://prismic.io/docs/core-concepts/group",
-	IntegrationFields: "https://prismic.io/docs/core-concepts/integration-fields",
-	Slices: "https://prismic.io/docs/core-concepts/slices",
-	Choice: "https://prismic.io/docs/core-concepts/slices",
+	UID: "https://prismic.io/docs/field#uid",
+	Boolean: "https://prismic.io/docs/field#boolean",
+	Color: "https://prismic.io/docs/field#color",
+	Date: "https://prismic.io/docs/field#date",
+	Timestamp: "https://prismic.io/docs/field#timestamp",
+	Number: "https://prismic.io/docs/field#number",
+	Text: "https://prismic.io/docs/field#key-text",
+	Select: "https://prismic.io/docs/field#select",
+	StructuredText: "https://prismic.io/docs/field#rich-text-title",
+	Image: "https://prismic.io/docs/field#image",
+	Link: "https://prismic.io/docs/field#link-content-relationship",
+	Embed: "https://prismic.io/docs/field#embed",
+	GeoPoint: "https://prismic.io/docs/field#geopoint",
+	Group: "https://prismic.io/docs/field#group",
+	IntegrationFields: "https://prismic.io/docs/field#integration",
+	Slices: "https://prismic.io/docs/field#slices",
+	Choice: "https://prismic.io/docs/field#slices",
 };

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