@angeloashmore/prismic-cli-poc 0.0.0-canary.fe51fbb → 0.0.0-pr.10.032f7ef

package/src/custom-type-add-field-uid.ts

@@ -6,6 +6,7 @@ import * as v from "valibot";
 
 import { buildTypes } from "./codegen-types";
 import { findUpward } from "./lib/file";
+import { parseFieldPath, validateNestedFieldPath } from "./lib/field-path";
 import { stringify } from "./lib/json";
 import { humanReadable } from "./lib/string";
 
@@ -76,6 +77,22 @@ export async function customTypeAddFieldUid(): Promise<void> {
 		return;
 	}
 
+	// Parse and validate field path
+	const fieldPath = parseFieldPath(fieldId);
+	const pathValidation = validateNestedFieldPath(fieldPath);
+	if (!pathValidation.ok) {
+		console.error(pathValidation.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	// UID fields cannot be nested in groups
+	if (fieldPath.type === "nested") {
+		console.error("UID fields cannot be nested inside groups");
+		process.exitCode = 1;
+		return;
+	}
+
 	// Find the custom type file
 	const projectRoot = await findUpward("package.json");
 	if (!projectRoot) {

package/src/custom-type-add-field.ts

@@ -5,6 +5,7 @@ import { customTypeAddFieldColor } from "./custom-type-add-field-color";
 import { customTypeAddFieldDate } from "./custom-type-add-field-date";
 import { customTypeAddFieldEmbed } from "./custom-type-add-field-embed";
 import { customTypeAddFieldGeoPoint } from "./custom-type-add-field-geo-point";
+import { customTypeAddFieldGroup } from "./custom-type-add-field-group";
 import { customTypeAddFieldImage } from "./custom-type-add-field-image";
 import { customTypeAddFieldKeyText } from "./custom-type-add-field-key-text";
 import { customTypeAddFieldLink } from "./custom-type-add-field-link";
@@ -26,6 +27,7 @@ FIELD TYPES
   date                   Date picker
   embed                  Embed (oEmbed)
   geo-point              Geographic coordinates
+  group                  Repeatable group of fields
   image                  Image
   key-text               Single-line text
   link                   Any link type
@@ -76,6 +78,9 @@ export async function customTypeAddField(): Promise<void> {
 		case "geo-point":
 			await customTypeAddFieldGeoPoint();
 			break;
+		case "group":
+			await customTypeAddFieldGroup();
+			break;
 		case "image":
 			await customTypeAddFieldImage();
 			break;

package/src/docs-fetch.ts

@@ -0,0 +1,146 @@
+import { parseArgs } from "node:util";
+
+const HELP = `
+Fetch and display documentation from Prismic's docs site.
+
+USAGE
+  prismic docs fetch <path> [flags]
+
+ARGUMENTS
+  path    Documentation path with optional anchor (e.g., "nextjs" or "nextjs#set-up-a-prismic-client")
+
+FLAGS
+  -h, --help   Show help for command
+
+EXAMPLES
+  prismic docs fetch nextjs
+  prismic docs fetch nextjs#set-up-a-prismic-client
+
+LEARN MORE
+  Visit https://prismic.io/docs for the full documentation.
+`.trim();
+
+function parsePathAndAnchor(input: string): { path: string; anchor?: string } {
+	const hashIndex = input.indexOf("#");
+	if (hashIndex === -1) {
+		return { path: input };
+	}
+	return {
+		path: input.slice(0, hashIndex),
+		anchor: input.slice(hashIndex + 1),
+	};
+}
+
+async function fetchMarkdown(
+	url: string,
+): Promise<{ ok: true; content: string } | { ok: false; error: string }> {
+	try {
+		const response = await fetch(url);
+		if (response.status === 404) {
+			return { ok: false, error: `Documentation not found: ${url}` };
+		}
+		if (!response.ok) {
+			return {
+				ok: false,
+				error: `Failed to fetch documentation: ${response.status}`,
+			};
+		}
+		const content = await response.text();
+		return { ok: true, content };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { ok: false, error: `Network error: ${message}` };
+	}
+}
+
+function anchorToHeadingPattern(anchor: string): RegExp {
+	// Convert kebab-case anchor to a pattern that matches the heading text.
+	const pattern = anchor
+		.split("-")
+		.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+		.join("[\\s-]+");
+	return new RegExp(`^(#{1,6})\\s+${pattern}\\s*$`, "im");
+}
+
+function extractSection(
+	markdown: string,
+	anchor: string,
+): { ok: true; content: string } | { ok: false; error: string } {
+	const lines = markdown.split("\n");
+	const headingPattern = anchorToHeadingPattern(anchor);
+
+	let startIndex = -1;
+	let headingLevel = 0;
+
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].match(headingPattern);
+		if (match) {
+			startIndex = i;
+			headingLevel = match[1].length;
+			break;
+		}
+	}
+
+	if (startIndex === -1) {
+		return { ok: false, error: `Anchor not found: #${anchor}` };
+	}
+
+	let endIndex = lines.length;
+	for (let i = startIndex + 1; i < lines.length; i++) {
+		const headingMatch = lines[i].match(/^(#{1,6})\s/);
+		if (headingMatch && headingMatch[1].length <= headingLevel) {
+			endIndex = i;
+			break;
+		}
+	}
+
+	const content = lines.slice(startIndex, endIndex).join("\n").trim();
+	return { ok: true, content };
+}
+
+export async function docsFetch(): Promise<void> {
+	const {
+		positionals: [pathArg],
+		values: { help },
+	} = parseArgs({
+		args: process.argv.slice(4),
+		options: {
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!pathArg) {
+		console.info(HELP);
+		return;
+	}
+
+	const { path, anchor } = parsePathAndAnchor(pathArg);
+	const url = `https://prismic.io/docs/${path}.md`;
+
+	const fetchResult = await fetchMarkdown(url);
+	if (!fetchResult.ok) {
+		console.error(fetchResult.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	let output = fetchResult.content;
+
+	if (anchor) {
+		const extractResult = extractSection(output, anchor);
+		if (!extractResult.ok) {
+			console.error(extractResult.error);
+			process.exitCode = 1;
+			return;
+		}
+		output = extractResult.content;
+	}
+
+	console.info(output);
+}

package/src/docs-list.ts

@@ -0,0 +1,131 @@
+import { parseArgs } from "node:util";
+
+const HELP = `
+List documentation pages from Prismic's docs site.
+
+USAGE
+  prismic docs list [flags]
+
+FLAGS
+  -h, --help   Show help for command
+
+EXAMPLES
+  prismic docs list
+`.trim();
+
+const ROOT_SITEMAP_URL = "https://prismic.io/docs/sitemap.xml";
+
+function decodeXmlEntities(input: string): string {
+	return input
+		.replaceAll("&", "&")
+		.replaceAll("&lt;", "<")
+		.replaceAll("&gt;", ">")
+		.replaceAll("&quot;", '"')
+		.replaceAll("&apos;", "'");
+}
+
+function extractLocEntries(xml: string): string[] {
+	const locPattern = /<loc>(.*?)<\/loc>/g;
+	const entries: string[] = [];
+	let match = locPattern.exec(xml);
+
+	while (match) {
+		entries.push(decodeXmlEntities(match[1]).trim());
+		match = locPattern.exec(xml);
+	}
+
+	return entries.filter(Boolean);
+}
+
+async function fetchXml(url: string): Promise<{ ok: true; xml: string } | { ok: false; error: string }> {
+	try {
+		const response = await fetch(url);
+		if (!response.ok) {
+			return {
+				ok: false,
+				error: `Failed to fetch sitemap: ${response.status} (${url})`,
+			};
+		}
+
+		return {
+			ok: true,
+			xml: await response.text(),
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { ok: false, error: `Network error while fetching sitemap ${url}: ${message}` };
+	}
+}
+
+function toDocsPath(urlString: string): string | null {
+	try {
+		const url = new URL(urlString);
+		if (url.hostname !== "prismic.io") {
+			return null;
+		}
+
+		if (!url.pathname.startsWith("/docs/")) {
+			return null;
+		}
+
+		return url.pathname.replace(/^\/docs\//, "").replace(/^\/+|\/+$/g, "");
+	} catch {
+		return null;
+	}
+}
+
+export async function docsList(): Promise<void> {
+	const {
+		values: { help },
+	} = parseArgs({
+		args: process.argv.slice(4),
+		options: {
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	const rootResult = await fetchXml(ROOT_SITEMAP_URL);
+	if (!rootResult.ok) {
+		console.error(rootResult.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const nestedSitemapUrls = extractLocEntries(rootResult.xml);
+	if (nestedSitemapUrls.length === 0) {
+		console.error(`No nested sitemaps found in ${ROOT_SITEMAP_URL}`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const nestedResults = await Promise.all(nestedSitemapUrls.map((url) => fetchXml(url)));
+	const failedFetch = nestedResults.find((result) => !result.ok);
+	if (failedFetch && !failedFetch.ok) {
+		console.error(failedFetch.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const paths = new Set<string>();
+
+	for (const nestedResult of nestedResults) {
+		if (!nestedResult.ok) continue;
+
+		for (const url of extractLocEntries(nestedResult.xml)) {
+			const path = toDocsPath(url);
+			if (path) {
+				paths.add(path);
+			}
+		}
+	}
+
+	for (const path of [...paths].sort((a, b) => a.localeCompare(b))) {
+		console.info(path);
+	}
+}

package/src/docs.ts

@@ -1,149 +1,54 @@
 import { parseArgs } from "node:util";
+import { docsFetch } from "./docs-fetch";
+import { docsList } from "./docs-list";
 
 const HELP = `
-Fetch and display documentation from Prismic's docs site.
+Fetch and list documentation from Prismic's docs site.
 
 USAGE
-  prismic docs <path> [flags]
+  prismic docs <command> [flags]
 
-ARGUMENTS
-  path    Documentation path with optional anchor (e.g., "nextjs" or "nextjs#set-up-a-prismic-client")
+COMMANDS
+  fetch      Fetch and display a documentation page
+  list       List documentation pages
 
 FLAGS
   -h, --help   Show help for command
 
 EXAMPLES
-  prismic docs nextjs
-  prismic docs nextjs#set-up-a-prismic-client
+  prismic docs fetch nextjs
+  prismic docs fetch nextjs#set-up-a-prismic-client
+  prismic docs list
 
 LEARN MORE
-  Visit https://prismic.io/docs for the full documentation.
+  Use \`prismic docs <command> --help\` for more information about a command.
 `.trim();
 
-function parsePathAndAnchor(input: string): { path: string; anchor?: string } {
-	const hashIndex = input.indexOf("#");
-	if (hashIndex === -1) {
-		return { path: input };
-	}
-	return {
-		path: input.slice(0, hashIndex),
-		anchor: input.slice(hashIndex + 1),
-	};
-}
-
-async function fetchMarkdown(
-	url: string,
-): Promise<{ ok: true; content: string } | { ok: false; error: string }> {
-	try {
-		const response = await fetch(url);
-		if (response.status === 404) {
-			return { ok: false, error: `Documentation not found: ${url}` };
-		}
-		if (!response.ok) {
-			return {
-				ok: false,
-				error: `Failed to fetch documentation: ${response.status}`,
-			};
-		}
-		const content = await response.text();
-		return { ok: true, content };
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return { ok: false, error: `Network error: ${message}` };
-	}
-}
-
-function anchorToHeadingPattern(anchor: string): RegExp {
-	// Convert kebab-case anchor to a pattern that matches the heading text
-	// Each hyphen/space becomes a flexible match for hyphens or spaces
-	const pattern = anchor
-		.split("-")
-		.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-		.join("[\\s-]+");
-	return new RegExp(`^(#{1,6})\\s+${pattern}\\s*$`, "im");
-}
-
-function extractSection(
-	markdown: string,
-	anchor: string,
-): { ok: true; content: string } | { ok: false; error: string } {
-	const lines = markdown.split("\n");
-	const headingPattern = anchorToHeadingPattern(anchor);
-
-	let startIndex = -1;
-	let headingLevel = 0;
-
-	// Find the matching heading
-	for (let i = 0; i < lines.length; i++) {
-		const match = lines[i].match(headingPattern);
-		if (match) {
-			startIndex = i;
-			headingLevel = match[1].length;
-			break;
-		}
-	}
-
-	if (startIndex === -1) {
-		return { ok: false, error: `Anchor not found: #${anchor}` };
-	}
-
-	// Find the end of this section (next heading of equal or lower level number)
-	let endIndex = lines.length;
-	for (let i = startIndex + 1; i < lines.length; i++) {
-		const headingMatch = lines[i].match(/^(#{1,6})\s/);
-		if (headingMatch && headingMatch[1].length <= headingLevel) {
-			endIndex = i;
-			break;
-		}
-	}
-
-	const content = lines.slice(startIndex, endIndex).join("\n").trim();
-	return { ok: true, content };
-}
-
 export async function docs(): Promise<void> {
 	const {
-		positionals: [pathArg],
-		values: { help },
+		positionals: [subcommand],
 	} = parseArgs({
 		args: process.argv.slice(3),
 		options: {
 			help: { type: "boolean", short: "h" },
 		},
 		allowPositionals: true,
+		strict: false,
 	});
 
-	if (help) {
-		console.info(HELP);
-		return;
-	}
-
-	if (!pathArg) {
-		console.info(HELP);
-		return;
-	}
-
-	const { path, anchor } = parsePathAndAnchor(pathArg);
-	const url = `https://prismic.io/docs/${path}.md`;
-
-	const fetchResult = await fetchMarkdown(url);
-	if (!fetchResult.ok) {
-		console.error(fetchResult.error);
-		process.exitCode = 1;
-		return;
-	}
-
-	let output = fetchResult.content;
-
-	if (anchor) {
-		const extractResult = extractSection(output, anchor);
-		if (!extractResult.ok) {
-			console.error(extractResult.error);
-			process.exitCode = 1;
-			return;
+	switch (subcommand) {
+		case "fetch":
+			await docsFetch();
+			break;
+		case "list":
+			await docsList();
+			break;
+		default: {
+			if (subcommand) {
+				console.error(`Unknown docs subcommand: ${subcommand}\n`);
+				process.exitCode = 1;
+			}
+			console.info(HELP);
 		}
-		output = extractResult.content;
 	}
-
-	console.info(output);
 }

package/src/index.ts

@@ -41,7 +41,7 @@ COMMANDS
   pull        Pull types and slices from Prismic
   push        Push types and slices to Prismic
   codegen     Generate code from Prismic models
-  docs        Fetch documentation from Prismic
+  docs        Fetch and list documentation from Prismic
   preview     Manage preview configurations
   token       Manage API tokens in a repository
   webhook     Manage webhooks in a repository

package/src/lib/field-path.ts

@@ -0,0 +1,81 @@
+export type FieldPath =
+	| { type: "top-level"; fieldId: string }
+	| { type: "nested"; groupId: string; nestedFieldId: string };
+
+export function parseFieldPath(fieldId: string): FieldPath {
+	const parts = fieldId.split(".");
+
+	if (parts.length === 1) {
+		return { type: "top-level", fieldId };
+	}
+
+	if (parts.length === 2) {
+		return { type: "nested", groupId: parts[0], nestedFieldId: parts[1] };
+	}
+
+	// More than 2 parts means nested groups which aren't supported
+	return { type: "nested", groupId: parts[0], nestedFieldId: parts.slice(1).join(".") };
+}
+
+export type GroupFieldResult =
+	| { ok: true; group: { config: { fields: Record<string, unknown> } } }
+	| { ok: false; error: string };
+
+export function isGroupField(field: unknown): field is { type: "Group"; config: { fields: Record<string, unknown> } } {
+	return (
+		typeof field === "object" &&
+		field !== null &&
+		"type" in field &&
+		field.type === "Group" &&
+		"config" in field &&
+		typeof field.config === "object" &&
+		field.config !== null &&
+		"fields" in field.config
+	);
+}
+
+export function findGroupInTab(
+	tabFields: Record<string, unknown>,
+	groupId: string,
+	tabName: string,
+): GroupFieldResult {
+	const field = tabFields[groupId];
+
+	if (!field) {
+		return { ok: false, error: `Group "${groupId}" not found in tab "${tabName}"` };
+	}
+
+	if (!isGroupField(field)) {
+		return { ok: false, error: `Field "${groupId}" is not a group` };
+	}
+
+	return { ok: true, group: field };
+}
+
+export function findGroupInVariation(
+	primary: Record<string, unknown>,
+	groupId: string,
+	variationId: string,
+): GroupFieldResult {
+	const field = primary[groupId];
+
+	if (!field) {
+		return { ok: false, error: `Group "${groupId}" not found in variation "${variationId}"` };
+	}
+
+	if (!isGroupField(field)) {
+		return { ok: false, error: `Field "${groupId}" is not a group` };
+	}
+
+	return { ok: true, group: field };
+}
+
+export function validateNestedFieldPath(fieldPath: FieldPath): { ok: true } | { ok: false; error: string } {
+	if (fieldPath.type === "nested" && fieldPath.nestedFieldId.includes(".")) {
+		return {
+			ok: false,
+			error: `Nested groups not supported. Use: group.field`,
+		};
+	}
+	return { ok: true };
+}

package/src/page-type-add-field-boolean.ts

@@ -6,6 +6,7 @@ import * as v from "valibot";
 
 import { buildTypes } from "./codegen-types";
 import { findUpward } from "./lib/file";
+import { findGroupInTab, isGroupField, parseFieldPath, validateNestedFieldPath } from "./lib/field-path";
 import { type Framework, detectFrameworkInfo } from "./lib/framework";
 import { stringify } from "./lib/json";
 import { humanReadable } from "./lib/string";
@@ -100,6 +101,15 @@ export async function pageTypeAddFieldBoolean(): Promise<void> {
 		return;
 	}
 
+	// Parse and validate field path
+	const fieldPath = parseFieldPath(fieldId);
+	const pathValidation = validateNestedFieldPath(fieldPath);
+	if (!pathValidation.ok) {
+		console.error(pathValidation.error);
+		process.exitCode = 1;
+		return;
+	}
+
 	// Find the page type file
 	const projectRoot = await findUpward("package.json");
 	if (!projectRoot) {
@@ -146,20 +156,11 @@ export async function pageTypeAddFieldBoolean(): Promise<void> {
 		model.json[targetTab] = {};
 	}
 
-	// Check if field already exists in any tab
-	for (const [tabName, tabFields] of Object.entries(model.json)) {
-		if (tabFields[fieldId]) {
-			console.error(`Field "${fieldId}" already exists in tab "${tabName}"`);
-			process.exitCode = 1;
-			return;
-		}
-	}
-
 	// Build field definition
 	const fieldDefinition: BooleanField = {
 		type: "Boolean",
 		config: {
-			label: label ?? humanReadable(fieldId),
+			label: label ?? humanReadable(fieldPath.type === "nested" ? fieldPath.nestedFieldId : fieldId),
 			...(defaultValue && { default_value: true }),
 			...(trueLabel && { placeholder_true: trueLabel }),
 			...(falseLabel && { placeholder_false: falseLabel }),
@@ -167,7 +168,36 @@ export async function pageTypeAddFieldBoolean(): Promise<void> {
 	};
 
 	// Add field to model
-	model.json[targetTab][fieldId] = fieldDefinition;
+	if (fieldPath.type === "nested") {
+		const groupResult = findGroupInTab(model.json[targetTab], fieldPath.groupId, targetTab);
+		if (!groupResult.ok) {
+			console.error(groupResult.error);
+			process.exitCode = 1;
+			return;
+		}
+		if (groupResult.group.config.fields[fieldPath.nestedFieldId]) {
+			console.error(`Field "${fieldPath.nestedFieldId}" already exists in group "${fieldPath.groupId}"`);
+			process.exitCode = 1;
+			return;
+		}
+		groupResult.group.config.fields[fieldPath.nestedFieldId] = fieldDefinition;
+	} else {
+		for (const [tabName, tabFields] of Object.entries(model.json)) {
+			if (tabFields[fieldId]) {
+				console.error(`Field "${fieldId}" already exists in tab "${tabName}"`);
+				process.exitCode = 1;
+				return;
+			}
+			for (const [groupFieldId, groupField] of Object.entries(tabFields)) {
+				if (isGroupField(groupField) && groupField.config.fields[fieldId]) {
+					console.error(`Field "${fieldId}" already exists in group "${groupFieldId}" in tab "${tabName}"`);
+					process.exitCode = 1;
+					return;
+				}
+			}
+		}
+		model.json[targetTab][fieldId] = fieldDefinition;
+	}
 
 	// Write updated model
 	try {
@@ -182,7 +212,11 @@ export async function pageTypeAddFieldBoolean(): Promise<void> {
 		return;
 	}
 
-	console.info(`Added field "${fieldId}" (Boolean) to "${targetTab}" tab in ${typeId}`);
+	if (fieldPath.type === "nested") {
+		console.info(`Added field "${fieldPath.nestedFieldId}" (Boolean) to group "${fieldPath.groupId}" in ${typeId}`);
+	} else {
+		console.info(`Added field "${fieldId}" (Boolean) to "${targetTab}" tab in ${typeId}`);
+	}
 
 	try {
 		await buildTypes({ output: types });
@@ -198,7 +232,7 @@ export async function pageTypeAddFieldBoolean(): Promise<void> {
 	if (frameworkInfo?.framework) {
 		const docsPath = getDocsPath(frameworkInfo.framework);
 		console.info(
-			`      Run \`prismic docs ${docsPath}#write-page-components\` to learn how to implement a page file`,
+			`      Run \`prismic docs fetch ${docsPath}#write-page-components\` to learn how to implement a page file`,
 		);
 	}
 }