prismic-ts-codegen 0.1.28 → 0.1.29-pr.80.577ac11

package/src/cli/configSchema.ts

@@ -1,54 +1,185 @@
-import Joi from "joi";
+import { z } from "zod";
 
-import { Config } from "./types";
+/** Configuration to control the generated types. */
+export const configSchema = z.object({
+	/** The name of the Prismic repository. */
+	repositoryName: z.string().optional(),
 
-export const configSchema = Joi.object<Config>({
-	repositoryName: Joi.string()
-		.when("locales.fetchFromRepository", {
-			is: true,
-			then: Joi.required(),
+	/**
+	 * The access token for the Prismic repository. If the repository is private and
+	 * `locales.fetchFromRepository` is `true`, providing a token is required.
+	 */
+	accessToken: z.string().optional(),
+
+	/**
+	 * The Custom Types API token for the Prismic repository. If `models.fetchFromRepository` is
+	 * `true`, providing a token is required.
+	 */
+	customTypesAPIToken: z.string().optional(),
+
+	/**
+	 * The file path where the generated types will be saved. This path is relative to where the
+	 * command is called.
+	 */
+	output: z.string().optional(),
+
+	/**
+	 * The package that provides TypeScript types for Prismic data. Most projects will not need to
+	 * configure this option.
+	 *
+	 * @defaultValue Automatically detected using the project's `package.json`.
+	 */
+	typesProvider: z.enum(["@prismicio/client", "@prismicio/types"]).optional(),
+
+	/** Configuration for automatic `@prismicio/client` integration. */
+	clientIntegration: z
+		.object({
+			/**
+			 * Determines if a `@prismicio/client` integration with automatic typing should be included in
+			 * the output.
+			 *
+			 * If set to `true`, Prismic clients will automatically be typed with the generated Custom
+			 * Types and Slices.
+			 *
+			 * **Note**: If your project queries content from multiple Prismic repositories, set
+			 * `includeCreateClientInterface` to `true` for the primary repository and `false` or any
+			 * other repository. The generated `AllDocumentTypes` type for non-primary repositories can be
+			 * provided to `@prismicio/client`'s `createClient()` function as its only type parameter to
+			 * type the client.
+			 *
+			 * @defaultValue `true`
+			 */
+			includeCreateClientInterface: z.boolean().optional(),
+
+			/**
+			 * Determines if a `@prismicio/client` namespace named `Content` containing all Document and
+			 * Slice types should be included in the output.
+			 *
+			 * If set to `true`, a `Content` namespace from `@prismicio/client` will be available to
+			 * import to easily access types for your Prismic repository content.
+			 *
+			 * **Note**: If your project queries content from multiple Prismic repositories, set
+			 * `includeContentNamespace` to `true` for the primary repository and `false` or any other
+			 * repository. Types for non-primary repositories should be imported directly from the
+			 * generated file rather than via the `Content` namespace.
+			 *
+			 * @defaultValue `true`
+			 */
+			includeContentNamespace: z.boolean().optional(),
 		})
-		.when("models.fetchFromRepository", {
-			is: true,
-			then: Joi.required(),
-		}),
-	accessToken: Joi.string(),
-	customTypesAPIToken: Joi.string(),
-
-	output: Joi.string(),
-
-	typesProvider: Joi.string().allow("@prismicio/client", "@prismicio/client"),
-
-	clientIntegration: Joi.object({
-		includeCreateClientInterface: Joi.boolean(),
-		includeContentNamespace: Joi.boolean(),
-	}),
-
-	locales: Joi.alternatives(
-		Joi.array().items(Joi.string().required()),
-		Joi.object({
-			ids: Joi.array().items(Joi.string().required()),
-			fetchFromRepository: Joi.boolean(),
-		}),
-	),
-
-	models: Joi.alternatives(
-		Joi.array().items(Joi.string()),
-		Joi.object({
-			files: Joi.array().items(Joi.string()),
-			fetchFromRepository: Joi.boolean(),
-		}),
-	),
-
-	fields: Joi.object({
-		embed: Joi.object({
-			providerTypes: Joi.object().pattern(
-				Joi.string(),
-				Joi.string().required(),
-			),
-		}),
-		integrationFields: Joi.object({
-			catalogTypes: Joi.object().pattern(Joi.string(), Joi.string().required()),
-		}),
-	}),
+		.optional(),
+
+	/**
+	 * Configuration for languages for the Prismic repository.
+	 *
+	 * It can be configured by providing an array of locale IDs configured for the repository or an
+	 * object with finer control.
+	 *
+	 * @example
+	 * 	```ts
+	 * 	["en-us", "fr-fr"];
+	 * 	```;
+	 *
+	 * @example
+	 * 	```ts
+	 * 	{
+	 * 	"ids": ["en-us", "fr-fr"],
+	 * 	"fetchFromRepository": true
+	 * 	}
+	 * 	```;
+	 */
+	locales: z
+		.union([
+			z.array(z.string()),
+			z.object({
+				/**
+				 * A list of locales configured for the Prismic repository. This is used to type a
+				 * document's `lang` property.
+				 *
+				 * @example
+				 * 	```ts
+				 * 	["en-us", "fr-fr"];
+				 * 	```;
+				 */
+				ids: z.array(z.string()).optional(),
+
+				/**
+				 * Determines if the Prismic repository's locales should be fetched from the repository's
+				 * API.
+				 */
+				fetchFromRepository: z.boolean().optional(),
+			}),
+		])
+		.optional(),
+
+	/**
+	 * Configuration for Custom Type and Slice models for the Prismic repository.
+	 *
+	 * It can be configured by providing an array of file paths to Custom Type and Slice JSON models
+	 * or an object with finer control.
+	 */
+	models: z
+		.union([
+			z.array(z.string()),
+			z.object({
+				/** A list of file paths to Custom Type and Slice models. Globs are supported. */
+				files: z.array(z.string()).optional(),
+
+				/**
+				 * Determines if the Prismic repository's Custom Type and Slice models should be fetched
+				 * from the repository's API.
+				 *
+				 * `customTypesAPIToken` must be provided if set to `true`.
+				 */
+				fetchFromRepository: z.boolean().optional(),
+			}),
+		])
+		.optional(),
+
+	/** Configuration for types generated for fields. */
+	fields: z
+		.object({
+			/** Configuration for Embed fields. */
+			embed: z
+				.object({
+					/**
+					 * An object mapping oEmbed providers to their type. The type should be provided as a
+					 * string and is added directly into the generated types.
+					 *
+					 * @example
+					 * 	```ts
+					 * 	{
+					 * 	"YouTube": "import('./types').OEmbedYouTube"
+					 * 	"Twitter": "import('./types').OEmbedTwitter"
+					 * 	"Vimeo": "import('./types').OEmbedVimeo"
+					 * 	}
+					 * 	```;
+					 */
+					providerTypes: z.record(z.string(), z.string()).optional(),
+				})
+				.optional(),
+
+			/** Configuration for Integration Fields. */
+			integrationFields: z
+				.object({
+					/**
+					 * An object mapping catalog IDs to their type. The type should be provided as a string
+					 * and is added directly into the generated types.
+					 *
+					 * @example
+					 * 	```ts
+					 * 	{
+					 * 	"shopify_products": "import('./types').IntegrationFieldShopifyProduct"
+					 * 	"mux_videos": "import('./types').IntegrationFieldMuxVideo"
+					 * 	}
+					 * 	```;
+					 */
+					catalogTypes: z.record(z.string(), z.string()).optional(),
+				})
+				.optional(),
+		})
+		.optional(),
 });
+
+/** Configuration to control the generated types. */
+export type Config = z.infer<typeof configSchema>;

package/src/cli/constants.ts

@@ -1,2 +1 @@
-export const NON_EDITABLE_FILE_HEADER =
-	"// Code generated by prismic-ts-codegen. DO NOT EDIT.";
+export const NON_EDITABLE_FILE_HEADER = "// Code generated by prismic-ts-codegen. DO NOT EDIT.";

package/src/cli/index.ts

@@ -1,10 +1,10 @@
-import { stripIndent } from "common-tags";
 import { existsSync, writeFileSync } from "fs";
-import meow from "meow";
 import { resolve as resolvePath } from "path";
 
-import { detectTypesProvider, generateTypes } from "../index";
+import { stripIndent } from "common-tags";
+import meow from "meow";
 
+import { detectTypesProvider, generateTypes } from "../index";
 import { configSchema } from "./configSchema";
 import { NON_EDITABLE_FILE_HEADER } from "./constants";
 import { loadConfig } from "./loadConfig";
@@ -74,13 +74,12 @@ const main = async () => {
 	} else {
 		const unvalidatedConfig = loadConfig({ path: cli.flags.config });
 
-		const { value: config, error } = configSchema.validate(unvalidatedConfig);
+		const result = configSchema.safeParse(unvalidatedConfig);
 
-		if (config && !error) {
+		if (result.success) {
+			const config = result.data;
 			const { customTypeModels, sharedSliceModels } = await loadModels({
-				localPaths: Array.isArray(config.models)
-					? config.models
-					: config.models?.files,
+				localPaths: Array.isArray(config.models) ? config.models : config.models?.files,
 				repositoryName: config.repositoryName,
 				customTypesAPIToken: config.customTypesAPIToken,
 				fetchFromRepository:
@@ -90,9 +89,7 @@ const main = async () => {
 			});
 
 			const localeIDs = await loadLocaleIDs({
-				localeIDs: Array.isArray(config.locales)
-					? config.locales
-					: config.locales?.ids,
+				localeIDs: Array.isArray(config.locales) ? config.locales : config.locales?.ids,
 				repositoryName: config.repositoryName,
 				accessToken: config.accessToken,
 				fetchFromRepository:
@@ -101,15 +98,11 @@ const main = async () => {
 					config.locales.fetchFromRepository,
 			});
 
-			const typesProvider =
-				config.typesProvider || (await detectTypesProvider());
+			const typesProvider = config.typesProvider || (await detectTypesProvider());
 
 			const hasCustomTypeModels = customTypeModels.length > 0;
 
-			if (
-				config.clientIntegration?.includeCreateClientInterface &&
-				!hasCustomTypeModels
-			) {
+			if (config.clientIntegration?.includeCreateClientInterface && !hasCustomTypeModels) {
 				console.info(
 					"[INFO]: prismic-ts-codegen was configured to automatically integrate with `@prismicio/client`, but the integration was not generated because no Custom Type models were found. Automatic integration requires at least one Custom Type model.",
 				);
@@ -122,10 +115,9 @@ const main = async () => {
 				fieldConfigs: config.fields,
 				clientIntegration: {
 					includeCreateClientInterface: hasCustomTypeModels
-						? config.clientIntegration?.includeCreateClientInterface ?? true
+						? (config.clientIntegration?.includeCreateClientInterface ?? true)
 						: false,
-					includeContentNamespace:
-						config.clientIntegration?.includeContentNamespace ?? true,
+					includeContentNamespace: config.clientIntegration?.includeContentNamespace ?? true,
 				},
 				typesProvider,
 			});
@@ -140,10 +132,8 @@ const main = async () => {
 				process.stdout.write(types + "\n");
 			}
 		} else {
-			if (error) {
-				console.error(error.message);
-				process.exit(1);
-			}
+			console.error(result.error.message);
+			process.exit(1);
 		}
 	}
 };

package/src/cli/loadConfig.ts

@@ -1,23 +1,19 @@
 import { existsSync } from "fs";
-import _jiti from "jiti";
 import { resolve as resolvePath } from "path";
 
-import type { Config } from "./types";
+import _jiti from "jiti";
+
+import type { Config } from "./configSchema";
 
 const jiti = _jiti(process.cwd());
 
 const loadModuleWithJiti = <TModule>(id: string): TModule => {
 	const mod = jiti(id) as TModule | { default: TModule };
 
-	return typeof mod === "object" && mod !== null && "default" in mod
-		? mod.default
-		: mod;
+	return typeof mod === "object" && mod !== null && "default" in mod ? mod.default : mod;
 };
 
-const DEFAULT_CONFIG_PATHS = [
-	"prismicCodegen.config.ts",
-	"prismicCodegen.config.js",
-];
+const DEFAULT_CONFIG_PATHS = ["prismicCodegen.config.ts", "prismicCodegen.config.js"];
 
 type LoadConfigConfig = {
 	path?: string;

package/src/cli/loadLocaleIDs.ts

@@ -12,9 +12,7 @@ type LoadLocalesConfig =
 			fetchFromRepository?: boolean;
 	  };
 
-export const loadLocaleIDs = async (
-	config: LoadLocalesConfig,
-): Promise<string[]> => {
+export const loadLocaleIDs = async (config: LoadLocalesConfig): Promise<string[]> => {
 	const localeIDs = new Set<string>(config.localeIDs || []);
 
 	if ("repositoryName" in config && config.fetchFromRepository) {

package/src/cli/loadModels.ts

@@ -1,7 +1,8 @@
-import * as prismicCT from "@prismicio/custom-types-client";
+import { readFileSync } from "fs";
+
 import type { CustomTypeModel, SharedSliceModel } from "@prismicio/client";
+import * as prismicCT from "@prismicio/custom-types-client";
 import fg from "fast-glob";
-import { readFileSync } from "fs";
 import fetch from "node-fetch";
 
 const isCustomTypeModel = (input: unknown): input is CustomTypeModel => {
@@ -38,9 +39,7 @@ type LoadModelsReturnType = {
 	sharedSliceModels: SharedSliceModel[];
 };
 
-export const loadModels = async (
-	config: LoadModelsConfig,
-): Promise<LoadModelsReturnType> => {
+export const loadModels = async (config: LoadModelsConfig): Promise<LoadModelsReturnType> => {
 	const customTypeModels: Record<string, CustomTypeModel> = {};
 	const sharedSliceModels: Record<string, SharedSliceModel> = {};
 
@@ -52,11 +51,10 @@ export const loadModels = async (
 		});
 
 		if (config.fetchFromRepository) {
-			const [remoteCustomTypeModels, remoteSharedSliceModels] =
-				await Promise.all([
-					customTypesClient.getAllCustomTypes(),
-					customTypesClient.getAllSharedSlices(),
-				]);
+			const [remoteCustomTypeModels, remoteSharedSliceModels] = await Promise.all([
+				customTypesClient.getAllCustomTypes(),
+				customTypesClient.getAllSharedSlices(),
+			]);
 
 			for (const customTypeModel of remoteCustomTypeModels) {
 				customTypeModels[customTypeModel.id] = customTypeModel;

package/src/constants.ts

@@ -1,7 +1,6 @@
 import type { CustomTypeModelFieldType } from "@prismicio/client";
 
-export const CUSTOM_TYPES_DOCUMENTATION_URL =
-	"https://prismic.io/docs/content-modeling";
+export const CUSTOM_TYPES_DOCUMENTATION_URL = "https://prismic.io/docs/content-modeling";
 
 export const SHARED_SLICES_DOCUMENTATION_URL = "https://prismic.io/docs/slices";
 

package/src/detectTypesProvider.ts

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 
-import { TypesProvider } from "./generateTypes";
+import type { TypesProvider } from "./generateTypes";
 
 export type DetectTypesProviderConfig = {
 	cwd?: string;
@@ -10,9 +10,8 @@ export type DetectTypesProviderConfig = {
  * Detects which types provider should be used for a project.
  *
  * @param config - Configures the detection.
- *
  * @returns The types provider identifier to use, or `undefined` if on cannot be
- *   determined.
+ * determined.
  */
 export const detectTypesProvider = async (
 	config: DetectTypesProviderConfig = {},
@@ -22,11 +21,7 @@ export const detectTypesProvider = async (
 	const require = createRequire(cwd.endsWith("/") ? cwd : cwd + "/");
 
 	try {
-		if (
-			Number.parseInt(
-				require("@prismicio/client/package.json").version.split(".")[0],
-			) >= 7
-		) {
+		if (Number.parseInt(require("@prismicio/client/package.json").version.split(".")[0]) >= 7) {
 			return "@prismicio/client";
 		}
 	} catch {

package/src/generateTypes.ts

@@ -7,8 +7,7 @@ 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 type { FieldConfigs } from "./types";
 
 export type TypesProvider = "@prismicio/client" | "@prismicio/types";
 
@@ -47,17 +46,11 @@ export function generateTypes(config: GenerateTypesConfig = {}): string {
 
 			// 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 = addLine(`import type * as ${clientImportName} from "@prismicio/client";`, code);
 		}
 	}
 
-	code = addSection(
-		`type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };`,
-		code,
-	);
+	code = addSection(`type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };`, code);
 
 	code = addSection(
 		`

package/src/index.ts

@@ -6,6 +6,5 @@ export type { DetectTypesProviderConfig } from "./detectTypesProvider";
 
 // The CLI configuration type is exported at the root level for ease of access.
 // It is not used in the the library's code.
-export type { Config } from "./cli/types";
-
+export type { Config } from "./cli/configSchema";
 export { NON_EDITABLE_FILE_HEADER } from "./cli/constants";

package/src/lib/addBlankLine.ts

@@ -4,7 +4,7 @@ type AddBlankLineConfig = {
 	force?: boolean;
 };
 
-export function addBlankLine(state: string, config?: AddBlankLineConfig) {
+export function addBlankLine(state: string, config?: AddBlankLineConfig): string {
 	if ((!state || state.endsWith("\n\n")) && !config?.force) {
 		return state;
 	} else {

package/src/lib/addLine.ts

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

package/src/lib/addSection.ts

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

package/src/lib/addTrailingNewLine.ts

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

package/src/lib/buildCustomTypeDataType.ts

@@ -2,9 +2,7 @@ import type { CustomTypeModel } from "@prismicio/client";
 import { source } from "common-tags";
 
 import { buildTypeName } from "../lib/buildTypeName";
-
-import { AuxiliaryType, FieldConfigs } from "../types";
-
+import type { AuxiliaryType, FieldConfigs } from "../types";
 import { buildFieldProperties } from "./buildFieldProperties";
 import { getHumanReadableModelName } from "./getHumanReadableModelName";
 

package/src/lib/buildCustomTypeType.ts

@@ -1,11 +1,9 @@
 import type { CustomTypeModel } from "@prismicio/client";
 import { source } from "common-tags";
-import QuickLRU from "quick-lru";
-
-import { AuxiliaryType, FieldConfigs } from "../types";
+import type QuickLRU from "quick-lru";
 
 import { CUSTOM_TYPES_DOCUMENTATION_URL } from "../constants";
-
+import type { AuxiliaryType, FieldConfigs } from "../types";
 import { addSection } from "./addSection";
 import { buildCustomTypeDataType } from "./buildCustomTypeDataType";
 import { buildTypeName } from "./buildTypeName";
@@ -29,7 +27,7 @@ type BuildCustomTypeTypeReturnValue = {
 };
 
 export function buildCustomTypeType(
-	args: BuildCustomTypeTypesArgs,
+	args: BuildCustomTypeTypesArgs
 ): BuildCustomTypeTypeReturnValue {
 	if (args.cache) {
 		const key = getCacheKey(args.model);
@@ -84,7 +82,7 @@ export function buildCustomTypeType(
 			dataType.name
 		}>, "${args.model.id}", Lang>;
 		`,
-		code,
+		code
 	);
 
 	const result = {

package/src/lib/buildFieldDocs.ts

@@ -1,9 +1,7 @@
 import type { CustomTypeModelField } from "@prismicio/client";
 
-import { FieldPath } from "../types";
-
 import { FIELD_DOCUMENTATION_URLS } from "../constants";
-
+import type { FieldPath } from "../types";
 import { addLine } from "./addLine";
 import { getAPIIDPath } from "./getAPIIDPath";
 import { getHumanReadableModelName } from "./getHumanReadableModelName";
@@ -13,9 +11,7 @@ type GetFieldHumanReadableTypeArgs = {
 	field: CustomTypeModelField;
 };
 
-function getHumanReadableFieldType(
-	args: GetFieldHumanReadableTypeArgs,
-): string {
+function getHumanReadableFieldType(args: GetFieldHumanReadableTypeArgs): string {
 	switch (args.field.type) {
 		case "StructuredText": {
 			return "Rich Text";
@@ -24,9 +20,7 @@ function getHumanReadableFieldType(
 		case "IntegrationFields": {
 			const catalog = args.field.config?.catalog;
 
-			return `Integration Fields (Catalog: ${
-				catalog ? `\`${catalog}\`` : "*unknown*"
-			})`;
+			return `Integration Fields (Catalog: ${catalog ? `\`${catalog}\`` : "*unknown*"})`;
 		}
 
 		case "Link": {
@@ -81,9 +75,7 @@ function getDocumentationURL(args: getDocumentationURLArgs) {
 
 		default: {
 			const url =
-				FIELD_DOCUMENTATION_URLS[
-					args.field.type as keyof typeof FIELD_DOCUMENTATION_URLS
-				];
+				FIELD_DOCUMENTATION_URLS[args.field.type as keyof typeof FIELD_DOCUMENTATION_URLS];
 
 			if (typeof url === "string") {
 				return url;
@@ -111,19 +103,14 @@ export function buildFieldDocs(args: BuildFieldDocsArgs): string {
 		field: args.field,
 	});
 
-	result = addLine(
-		` * ${humanReadableName} field in *${humanReadablePath}*`,
-		result,
-	);
+	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) ||
+		(args.field.config && "placeholder" in args.field.config && args.field.config.placeholder) ||
 		`*None*`;
 	result = addLine(` * - **Placeholder**: ${placeholder}`, result);
 
@@ -135,10 +122,7 @@ export function buildFieldDocs(args: BuildFieldDocsArgs): string {
 		const stringifiedDefaultValue =
 			typeof defaultValue === "boolean" ? `${defaultValue}` : defaultValue;
 
-		result = addLine(
-			` * - **Default Value**: ${stringifiedDefaultValue}`,
-			result,
-		);
+		result = addLine(` * - **Default Value**: ${stringifiedDefaultValue}`, result);
 	}
 
 	const apiIDPath = getAPIIDPath({