prismic-ts-codegen 0.1.11 → 0.1.12

package/src/lib/buildSharedSliceType.ts

@@ -0,0 +1,213 @@
+import { SharedSliceModel } from "@prismicio/client";
+import { source, stripIndent } from "common-tags";
+import QuickLRU from "quick-lru";
+
+import { FieldConfigs, FieldPath } from "../types";
+
+import { SHARED_SLICES_DOCUMENTATION_URL } from "../constants";
+
+import { addSection } from "./addSection";
+import { buildFieldProperties } from "./buildFieldProperties";
+import { buildTypeName } from "./buildTypeName";
+import { buildUnion } from "./buildUnion";
+import { getCacheKey } from "./getCacheKey";
+import { getHumanReadableModelName } from "./getHumanReadableModelName";
+import { getHumanReadablePath } from "./getHumanReadablePath";
+
+type BuildSharedSliceTypeArgs = {
+	model: SharedSliceModel;
+	fieldConfigs: FieldConfigs;
+	cache?: QuickLRU<string, unknown>;
+};
+
+type BuildSharedSliceTypeReturnValue = {
+	name: string;
+	variationUnionName: string;
+	variationNames: string[];
+	code: string;
+};
+
+export function buildSharedSliceType(
+	args: BuildSharedSliceTypeArgs,
+): BuildSharedSliceTypeReturnValue {
+	if (args.cache) {
+		const key = getCacheKey([args.model, args.fieldConfigs]);
+		const cached = args.cache.get(key);
+
+		if (cached) {
+			return cached as BuildSharedSliceTypeReturnValue;
+		}
+	}
+
+	let code = "";
+
+	const name = buildTypeName(args.model.id, "Slice");
+	const humanReadableName = getHumanReadableModelName({
+		name: args.model.id,
+		model: args.model,
+	});
+
+	const variationNames: string[] = [];
+	for (const variationModel of args.model.variations) {
+		const variationName = buildTypeName(name, variationModel.id);
+
+		let primaryInterfaceName: string | undefined;
+		if (
+			variationModel.primary &&
+			Object.keys(variationModel.primary).length > 0
+		) {
+			primaryInterfaceName = buildTypeName(variationName, "Primary");
+
+			const path: FieldPath = [
+				{
+					name: args.model.id,
+					model: args.model,
+				},
+				{
+					name: "primary",
+					label: "Primary",
+				},
+			];
+			const humanReadablePath = getHumanReadablePath({ path });
+
+			const primaryFieldProperties = buildFieldProperties({
+				fields: variationModel.primary,
+				fieldConfigs: args.fieldConfigs,
+				path,
+			});
+
+			const docs = stripIndent`
+				/**
+				 * Primary content in *${humanReadablePath}*
+				 */
+			`;
+
+			code = addSection(
+				primaryFieldProperties.code
+					? source`
+						${docs}
+						export interface ${primaryInterfaceName} {
+							${primaryFieldProperties.code}
+						}
+					`
+					: source`
+						${docs}
+						export interface ${primaryInterfaceName} {}
+					`,
+				code,
+			);
+		}
+
+		let itemInterfaceName: string | undefined;
+		if (variationModel.items && Object.keys(variationModel.items).length > 0) {
+			itemInterfaceName = buildTypeName(variationName, "Item");
+
+			const path: FieldPath = [
+				{
+					name: args.model.id,
+					model: args.model,
+				},
+				{
+					name: "items",
+					label: "Items",
+				},
+			];
+			const humanReadablePath = getHumanReadablePath({ path });
+
+			const itemFieldProperties = buildFieldProperties({
+				fields: variationModel.items,
+				fieldConfigs: args.fieldConfigs,
+				path,
+			});
+
+			const docs = stripIndent`
+				/**
+				 * Primary content in *${humanReadablePath}*
+				 */
+			`;
+
+			code = addSection(
+				itemFieldProperties.code
+					? source`
+						${docs}
+						export interface ${itemInterfaceName} {
+							${itemFieldProperties.code}
+						}
+					`
+					: source`
+						${docs}
+						export interface ${itemInterfaceName} {}
+					`,
+				code,
+			);
+		}
+
+		code = addSection(
+			source`
+				/**
+				 * ${variationModel.name} variation for ${humanReadableName} Slice
+				 *
+				 * - **API ID**: \`${variationModel.id}\`
+				 * - **Description**: ${variationModel.description || "*None*"}
+				 * - **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}
+				 */
+				export type ${variationName} = prismic.SharedSliceVariation<"${
+				variationModel.id
+			}", ${
+				primaryInterfaceName
+					? `Simplify<${primaryInterfaceName}>`
+					: `Record<string, never>`
+			}, ${itemInterfaceName ? `Simplify<${itemInterfaceName}>` : `never`}>;
+			`,
+			code,
+		);
+
+		variationNames.push(variationName);
+	}
+
+	const variationUnionName = buildTypeName(name, "Variation");
+	const variationsUnion = buildUnion(variationNames);
+
+	code = addSection(
+		source`
+			/**
+			 * Slice variation for *${humanReadableName}*
+			 */
+			type ${variationUnionName} = ${
+			variationNames.length > 0 ? variationsUnion : "never"
+		}
+		`,
+		code,
+	);
+
+	code = addSection(
+		source`
+			/**
+			 * ${humanReadableName} Shared Slice
+			 *
+			 * - **API ID**: \`${args.model.id}\`
+			 * - **Description**: ${args.model.description || "*None*"}
+			 * - **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}
+			 */
+			export type ${name} = prismic.SharedSlice<"${
+			args.model.id
+		}", ${variationUnionName}>;
+		`,
+		code,
+	);
+
+	const result = {
+		name,
+		variationUnionName,
+		variationNames,
+		code,
+	};
+
+	if (args.cache) {
+		const key = getCacheKey([args.model, args.fieldConfigs]);
+
+		args.cache.set(key, result);
+	}
+
+	return result;
+}

package/src/lib/buildTypeName.ts

@@ -1,7 +1,9 @@
-import { pascalCase } from "./pascalCase";
+import { pascalCase, pascalCaseTransformMerge } from "pascal-case";
 
 export const buildTypeName = (...parts: string[]) => {
-	let name = pascalCase(parts.filter(Boolean).join(" "));
+	let name = pascalCase(parts.filter(Boolean).join(" "), {
+		transform: pascalCaseTransformMerge,
+	});
 
 	if (/^[0-9]/.test(name) ? "_" : "") {
 		name = `_${name}`;

package/src/lib/buildUnion.ts

@@ -0,0 +1,3 @@
+export function buildUnion(types: string[]) {
+	return types.filter(Boolean).join(" | ");
+}

package/src/lib/checkHasUIDFIeld.ts

@@ -0,0 +1,5 @@
+import { CustomTypeModel } from "@prismicio/client";
+
+export function checkHasUIDField(model: CustomTypeModel): boolean {
+	return "uid" in Object.assign({}, ...Object.values(model.json));
+}

package/src/lib/getAPIIDPath.ts

@@ -1,45 +1,44 @@
-import type {
-	CustomTypeModel,
-	CustomTypeModelField,
-	CustomTypeModelSlice,
-	SharedSliceModel,
-} from "@prismicio/client";
-
-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>[],
-	];
+import { FieldPath } from "../types";
+
+type GetAPIIDPathArgs = {
+	path: FieldPath;
 };
 
-export const getAPIIDPath = (config: GetAPIIDPathConfig): string => {
-	return config.path
-		.map((element, i) => {
-			if (
-				isCustomTypeModelField(element.model) &&
-				(element.model.type === "Group" || element.model.type === "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}[]`;
-					}
-				}
+export function getAPIIDPath(args: GetAPIIDPathArgs) {
+	let result = "";
+
+	for (let i = 0; i < args.path.length; i++) {
+		if (i > 0) {
+			result += ".";
+		}
+
+		const element = args.path[i];
+
+		if (
+			element.model &&
+			"type" in element.model &&
+			(element.model.type === "Group" || element.model.type === "Slices")
+		) {
+			result += `${element.name}[]`;
+		} else {
+			if (element.name === "items") {
+				const previousElement = args.path[i - 1];
 
-				return element.id;
+				if (
+					(previousElement.model && "json" in previousElement.model) ||
+					(previousElement.model &&
+						"type" in previousElement.model &&
+						previousElement.model.type === "SharedSlice")
+				) {
+					result += `${element.name}[]`;
+
+					continue;
+				}
 			}
-		})
-		.join(".");
-};
+
+			result += element.name;
+		}
+	}
+
+	return result;
+}

package/src/lib/getCacheKey.ts

@@ -0,0 +1,13 @@
+import * as crypto from "node:crypto";
+
+/**
+ * Returns a key based on the provided input that can be used as a cache
+ * identifier.
+ *
+ * @param input - The value used to create a key.
+ *
+ * @returns The cache key.
+ */
+export const getCacheKey = (input: unknown): string => {
+	return crypto.createHash("sha1").update(JSON.stringify(input)).digest("hex");
+};

package/src/lib/getHumanReadableModelName.ts

@@ -5,13 +5,8 @@ import type {
 	SharedSliceModel,
 } from "@prismicio/client";
 
-import { isCustomTypeModel } from "./isCustomTypeModel";
-import { isCustomTypeModelField } from "./isCustomTypeModelField";
-import { isCustomTypeModelSlice } from "./isCustomTypeModelSlice";
-import { isSharedSliceModel } from "./isSharedSliceModel";
-
-type GetModelHumanNameConfig = {
-	id: string;
+type GetModelHumanNameArgs = {
+	name: string;
 	model:
 		| CustomTypeModel
 		| SharedSliceModel
@@ -20,23 +15,31 @@ type GetModelHumanNameConfig = {
 };
 
 export const getHumanReadableModelName = (
-	config: GetModelHumanNameConfig,
+	args: GetModelHumanNameArgs,
 ): string => {
-	if (isCustomTypeModel(config.model)) {
-		return config.model.label || config.model.id;
-	} else if (isSharedSliceModel(config.model)) {
-		return config.model.name;
-	} else if (isCustomTypeModelField(config.model)) {
-		if (config.model.config && "label" in config.model.config) {
+	if ("json" in args.model) {
+		// Custom type model
+
+		return args.model.label || args.model.id;
+	} else if ("type" in args.model && args.model.type === "SharedSlice") {
+		// Shared Slice model
+
+		return args.model.name;
+	} else if ("type" in args.model && args.model.type === "Slice") {
+		// Legacy Slice model
+
+		return args.model.fieldset || args.name;
+	} else if ("type" in args.model) {
+		// Field model
+
+		if (args.model.config && "label" in args.model.config) {
 			// Non-Slice Zone fields
-			return config.model.config.label || config.id;
-		} else if (config.model.config && "fieldset" in config.model) {
+			return args.model.config.label || args.name;
+		} else if (args.model.config && "fieldset" in args.model) {
 			// Slice Zone
-			return config.model.fieldset || config.id;
+			return args.model.fieldset || args.name;
 		}
-	} else if (isCustomTypeModelSlice(config.model)) {
-		return config.model.fieldset || config.id;
 	}
 
-	return `\`${config.id}\``;
+	return `\`${args.name}\``;
 };

package/src/lib/getHumanReadablePath.ts

@@ -0,0 +1,24 @@
+import { FieldPath } from "../types";
+
+import { getHumanReadableModelName } from "./getHumanReadableModelName";
+
+type GetHumanReadablePathArgs = {
+	path: FieldPath;
+};
+
+export function getHumanReadablePath(args: GetHumanReadablePathArgs) {
+	return args.path
+		.map((element) => {
+			if (element.label) {
+				return element.label;
+			} else if (element.model) {
+				return getHumanReadableModelName({
+					model: element.model,
+					name: element.name,
+				});
+			} else {
+				return element.name;
+			}
+		})
+		.join(" → ");
+}

package/src/types.ts

@@ -12,11 +12,21 @@ export type PathElement<
 		| CustomTypeModelField
 		| CustomTypeModelSlice,
 > = {
-	id: string;
+	name: string;
 	model?: Model;
 	label?: string;
 };
 
+export type FieldPath = [
+	PathElement<CustomTypeModel | SharedSliceModel>,
+	...PathElement<CustomTypeModelField | CustomTypeModelSlice>[],
+];
+
+export type AuxiliaryType = {
+	code: string;
+	name: string;
+};
+
 export type FieldConfigs = {
 	embed?: {
 		providerTypes?: Record<string, string>;