prismic-ts-codegen 0.1.11 → 0.1.13

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