prismic 0.0.0-pr.28.59bf330

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/lib/file.ts

@@ -0,0 +1,49 @@
+import { access } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+import { appendTrailingSlash } from "./url";
+
+export async function findUpward(
+	name: string,
+	config: { start?: URL; stop?: URL | string } = {},
+): Promise<URL | undefined> {
+	const { start = pathToFileURL(process.cwd()), stop } = config;
+
+	let dir = appendTrailingSlash(start);
+
+	while (true) {
+		const path = new URL(name, dir);
+		try {
+			await access(path);
+			return path;
+		} catch {}
+
+		if (typeof stop === "string") {
+			const stopPath = new URL(stop, dir);
+			try {
+				await access(stopPath);
+				return;
+			} catch {}
+		} else if (stop instanceof URL) {
+			if (stop.href === dir.href) {
+				return;
+			}
+		}
+
+		const parent = new URL("..", dir);
+		if (parent.href === dir.href) {
+			return undefined;
+		}
+
+		dir = parent;
+	}
+}
+
+export async function exists(path: URL): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/lib/json.ts

@@ -0,0 +1,3 @@
+export function stringify(input: unknown): string {
+	return JSON.stringify(input, null, 2);
+}

package/src/lib/packageJson.ts

@@ -0,0 +1,35 @@
+import detectIndent from "detect-indent";
+import { readFile, writeFile } from "node:fs/promises";
+
+import { findUpward } from "./file";
+
+export async function addDependencies(
+	dependencies: Record<string, string>,
+): Promise<void> {
+	const packageJsonPath = await findUpward("package.json");
+	if (!packageJsonPath) {
+		throw new Error("No package.json found");
+	}
+	const raw = await readFile(packageJsonPath, "utf8");
+	const indent = detectIndent(raw).indent || "\t";
+	const packageJson = JSON.parse(raw);
+	packageJson.dependencies = Object.fromEntries(
+		Object.entries({ ...packageJson.dependencies, ...dependencies }).sort(
+			([a], [b]) => a.localeCompare(b),
+		),
+	);
+	await writeFile(
+		packageJsonPath,
+		JSON.stringify(packageJson, null, indent) + "\n",
+	);
+}
+
+export async function getNpmPackageVersion(
+	name: string,
+	tag = "latest",
+): Promise<string> {
+	const url = new URL(`${name}/${tag}`, "https://registry.npmjs.org/");
+	const res = await fetch(url);
+	const { version } = await res.json();
+	return version;
+}

package/src/lib/profile.ts

@@ -0,0 +1,39 @@
+import * as v from "valibot";
+
+import { readToken } from "./auth";
+import { getUserServiceUrl } from "./url";
+
+const PrismicUserProfileSchema = v.object({
+	userId: v.string(),
+	shortId: v.string(),
+	intercomHash: v.string(),
+	email: v.string(),
+	firstName: v.string(),
+	lastName: v.string(),
+});
+
+export type PrismicUserProfile = v.InferOutput<typeof PrismicUserProfileSchema>;
+
+export async function getProfile(): Promise<PrismicUserProfile> {
+	const token = await readToken();
+	if (!token) {
+		throw new Error("Not authenticated. Log in before trying again.");
+	}
+
+	const baseUrl = await getUserServiceUrl();
+	const url = new URL("profile", baseUrl);
+
+	const response = await fetch(url, {
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error("Failed to retrieve profile from the Prismic user service.");
+	}
+
+	const json = await response.json();
+
+	return v.parse(PrismicUserProfileSchema, json);
+}

package/src/lib/request.ts

@@ -0,0 +1,116 @@
+import * as v from "valibot";
+
+import { readToken } from "./auth";
+
+type CustomRequestInit = Omit<RequestInit, "body"> & {
+	body?: RequestInit["body"] | Record<PropertyKey, unknown>;
+};
+
+export type RequestResponse<T> = SuccessfulRequestResponse<T> | FailedRequestResponse;
+export type ParsedRequestResponse<T> =
+	| RequestResponse<T>
+	| { ok: false; value: unknown; error: v.ValiError<v.GenericSchema<T>> };
+export type SuccessfulRequestResponse<T> = { ok: true; value: T };
+export type FailedRequestResponse = {
+	ok: false;
+	value: unknown;
+	error: RequestError | ForbiddenRequestError | UnauthorizedRequestError;
+};
+export type FailedParsedRequestResponse<T> =
+	| FailedRequestResponse
+	| { ok: false; value: unknown; error: v.ValiError<v.GenericSchema<T>> };
+
+export async function request<T>(
+	input: RequestInfo | URL,
+	init?: CustomRequestInit,
+): Promise<RequestResponse<T>>;
+export async function request<T>(
+	input: RequestInfo | URL,
+	init: CustomRequestInit & { schema: v.GenericSchema<T> },
+): Promise<ParsedRequestResponse<T>>;
+export async function request<T>(
+	input: RequestInfo | URL,
+	init: CustomRequestInit & { schema?: v.GenericSchema<T> } = {},
+): Promise<ParsedRequestResponse<T>> {
+	const { credentials = "include" } = init;
+
+	const headers = new Headers(init.headers);
+	headers.set("Accept", "application/json");
+	if (credentials === "include") {
+		const token = await readToken();
+		if (token) headers.set("Cookie", `SESSION=fake_session; prismic-auth=${token}`);
+	}
+	if (!headers.has("Content-Type") && init.body) {
+		headers.set("Content-Type", "application/json");
+	}
+	if (init.body instanceof FormData) {
+		headers.delete("Content-Type");
+	}
+
+	const body =
+		headers.get("Content-Type") === "application/json"
+			? JSON.stringify(init.body)
+			: (init.body as RequestInit["body"]);
+
+	const response = await fetch(input, { ...init, body, headers });
+
+	const value = await response
+		.clone()
+		.json()
+		.catch(() => response.clone().text());
+
+	if (response.ok) {
+		if (!init?.schema) return { ok: true, value };
+
+		try {
+			const parsed = v.parse(init.schema, value);
+			return { ok: true, value: parsed };
+		} catch (error) {
+			if (v.isValiError<v.GenericSchema<T>>(error)) {
+				return { ok: false, value, error };
+			}
+			throw error;
+		}
+	} else {
+		if (response.status === 401) {
+			const error = new UnauthorizedRequestError(response);
+			return { ok: false, value, error };
+		} else if (response.status === 403) {
+			const error = new ForbiddenRequestError(response);
+			return { ok: false, value, error };
+		} else {
+			const error = new RequestError(response);
+			return { ok: false, value, error };
+		}
+	}
+}
+
+export class RequestError extends Error {
+	name = "RequestError" as const;
+	response: Response;
+
+	constructor(response: Response) {
+		super(`fetch failed: ${response.url}`);
+		this.response = response;
+	}
+
+	async text(): Promise<string> {
+		return this.response.clone().text();
+	}
+
+	async json(): Promise<unknown> {
+		return this.response.clone().json();
+	}
+
+	get status(): number {
+		return this.response.status;
+	}
+
+	get statusText(): string {
+		return this.response.statusText;
+	}
+}
+
+export class ForbiddenRequestError extends RequestError {}
+
+export class UnauthorizedRequestError extends RequestError {}

package/src/lib/segment.ts

@@ -0,0 +1,145 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import packageJson from "../../package.json" with { type: "json" };
+
+const SEGMENT_WRITE_KEY =
+	process.env.PRISMIC_ENV && process.env.PRISMIC_ENV !== "production"
+		? "Ng5oKJHCGpSWplZ9ymB7Pu7rm0sTDeiG"
+		: "cGjidifKefYb6EPaGaqpt8rQXkv5TD6P";
+const SEGMENT_TRACK_URL = "https://api.segment.io/v1/track";
+
+let enabled = false;
+let anonymousId = "";
+let authorization = "";
+const appContext = { app: { name: packageJson.name, version: packageJson.version } };
+const eventQueue: Array<{ event: string; properties: Record<string, unknown> }> = [];
+
+export async function initSegment(): Promise<void> {
+	try {
+		enabled = await isTelemetryEnabled();
+		if (!enabled) {
+			return;
+		}
+
+		anonymousId = randomUUID();
+		authorization = `Basic ${btoa(SEGMENT_WRITE_KEY + ":")}`;
+		process.on("exit", flushTelemetry);
+	} catch {
+		enabled = false;
+	}
+}
+
+export function trackStart(command: string): void {
+	if (!enabled) {
+		return;
+	}
+
+	eventQueue.push({
+		event: "Prismic CLI Start",
+		properties: {
+			commandType: command,
+			fullCommand: process.argv.join(" "),
+		},
+	});
+}
+
+export function trackEnd(
+	command: string,
+	success: boolean,
+	error?: unknown,
+): void {
+	if (!enabled) {
+		return;
+	}
+
+	const properties: Record<string, unknown> = {
+		commandType: command,
+		fullCommand: process.argv.join(" "),
+		success,
+	};
+
+	if (error !== undefined) {
+		const message = error instanceof Error ? error.message : String(error);
+		properties.error = message.slice(0, 512);
+	}
+
+	eventQueue.push({ event: "Prismic CLI End", properties });
+}
+
+/**
+ * Spawns a detached subprocess to send queued telemetry events.
+ * The main process exits immediately; the subprocess handles HTTP delivery.
+ */
+function flushTelemetry(): void {
+	if (eventQueue.length === 0) {
+		return;
+	}
+
+	try {
+		const payload = Buffer.from(
+			JSON.stringify({
+				url: SEGMENT_TRACK_URL,
+				authorization,
+				events: eventQueue.map((e) => ({
+					anonymousId,
+					event: e.event,
+					properties: { nodeVersion: process.versions.node, ...e.properties },
+					context: appContext,
+					timestamp: new Date().toISOString(),
+				})),
+			}),
+		).toString("base64");
+
+		const child = spawn(
+			process.execPath,
+			["--input-type=module", "-e", FLUSH_SCRIPT, payload],
+			{ detached: true, stdio: "ignore" },
+		);
+		child.unref();
+	} catch {
+		// Silent failure — never breaks the CLI
+	}
+
+	eventQueue.length = 0;
+}
+
+const FLUSH_SCRIPT = `
+const {url, authorization, events} = JSON.parse(Buffer.from(process.argv[1], "base64"));
+const h = {"Content-Type": "application/json", Authorization: authorization};
+await Promise.allSettled(events.map(e => fetch(url, {method: "POST", headers: h, body: JSON.stringify(e)}).catch(() => {})));
+`;
+
+async function isTelemetryEnabled(): Promise<boolean> {
+	try {
+		// Check user-level .prismicrc
+		const userRc = await readJsonFile(join(homedir(), ".prismicrc"));
+		if (userRc?.telemetry === false) {
+			return false;
+		}
+
+		// Check project-level .prismicrc
+		const projectRc = await readJsonFile(join(process.cwd(), ".prismicrc"));
+		if (projectRc?.telemetry === false) {
+			return false;
+		}
+
+		return true;
+	} catch {
+		return true;
+	}
+}
+
+async function readJsonFile(
+	path: string,
+): Promise<Record<string, unknown> | undefined> {
+	try {
+		const contents = await readFile(path, "utf8");
+		return JSON.parse(contents);
+	} catch {
+		return undefined;
+	}
+}

package/src/lib/sentry.ts

@@ -0,0 +1,63 @@
+import * as Sentry from "@sentry/node-core/light";
+
+import packageJson from "../../package.json" with { type: "json" };
+
+const SENTRY_DSN =
+	import.meta.env.PRISMIC_SENTRY_DSN ||
+	"https://e1886b1775bd397cd1afc60bfd2ebfc8@o146123.ingest.us.sentry.io/4510445143588864";
+
+function isSentryEnabled(): boolean {
+	if (import.meta.env.PRISMIC_SENTRY_ENABLED === undefined) {
+		return import.meta.env.PROD;
+	}
+
+	return import.meta.env.PRISMIC_SENTRY_ENABLED === "true";
+}
+
+export function setupSentry(): void {
+	try {
+		if (!isSentryEnabled()) {
+			return;
+		}
+
+		Sentry.init({
+			dsn: SENTRY_DSN,
+			release: packageJson.version,
+			environment: import.meta.env.PRISMIC_SENTRY_ENVIRONMENT ?? "production",
+			defaultIntegrations: false,
+			integrations: [],
+			maxValueLength: 2_500,
+		});
+
+		Sentry.setContext("Process", {
+			command: process.argv.join(" "),
+			cwd: process.cwd(),
+		});
+	} catch {
+		// Silent failure — never breaks the CLI
+	}
+}
+
+export async function captureError(error: unknown): Promise<void> {
+	try {
+		if (!isSentryEnabled()) {
+			return;
+		}
+
+		Sentry.captureException(
+			error,
+			error instanceof Error
+				? { extra: { cause: error.cause, fullCommand: process.argv.join(" ") } }
+				: {},
+		);
+
+		await Sentry.flush();
+	} catch {
+		// Silent failure — never breaks the CLI
+	}
+}
+
+// Re-exports for future devtools-parity integration points
+export const setUser = Sentry.setUser;
+export const setTag = Sentry.setTag;
+export const setContext = Sentry.setContext;

package/src/lib/string.ts

@@ -0,0 +1,10 @@
+import baseDedent from "dedent";
+
+export function humanReadable(id: string): string {
+	return id
+		.replace(/([a-z])([A-Z])/g, "$1 $2")
+		.replace(/[_-]+/g, " ")
+		.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+export const dedent = baseDedent.withOptions({ alignValues: true });

package/src/lib/url.ts

@@ -0,0 +1,31 @@
+import { readHost } from "./auth";
+
+export async function getRepoUrl(repo: string): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `${repo}.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export async function getInternalApiUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `api.internal.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export async function getUserServiceUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `user-service.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export async function getAuthUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `auth.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export function appendTrailingSlash(url: string | URL): URL {
+	const newURL = new URL(url);
+	if (!newURL.pathname.endsWith("/")) newURL.pathname += "/";
+	return newURL;
+}

package/src/locale-add.ts

@@ -0,0 +1,116 @@
+import { parseArgs } from "node:util";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { stringify } from "./lib/json";
+import { ForbiddenRequestError, request } from "./lib/request";
+import { getRepoUrl } from "./lib/url";
+
+const HELP = `
+Add a new locale to a Prismic repository.
+
+By default, this command reads the repository from prismic.config.json at the
+project root.
+
+USAGE
+  prismic locale add <code> [flags]
+
+ARGUMENTS
+  <code>   Locale code (e.g. fr-fr, es-es)
+
+FLAGS
+  -n, --name string   Custom display name (creates custom locale)
+  -r, --repo string   Repository domain
+  -h, --help          Show help for command
+
+LEARN MORE
+  Use \`prismic <command> <subcommand> --help\` for more information about a command.
+`.trim();
+
+export async function localeAdd(): Promise<void> {
+	const {
+		values: { help, name, repo = await safeGetRepositoryFromConfig() },
+		positionals: [code],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "locale", "add"
+		options: {
+			name: { type: "string", short: "n" },
+			repo: { type: "string", short: "r" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!code) {
+		console.error("Missing required argument: <code>");
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!repo) {
+		console.error("Missing prismic.config.json or --repo option");
+		process.exitCode = 1;
+		return;
+	}
+
+	const authenticated = await isAuthenticated();
+	if (!authenticated) {
+		handleUnauthenticated();
+
+		return;
+	}
+
+	const response = name
+		? await addCustomLocale(repo, code, name)
+		: await addStandardLocale(repo, code);
+	if (!response.ok) {
+		if (
+			typeof response.value === "string" &&
+			response.value.includes("already existing languages")
+		) {
+			// Treat as success
+			return;
+		}
+
+		if (response.error instanceof ForbiddenRequestError) {
+			handleUnauthenticated();
+		} else {
+			console.error(`Failed to add locale: ${stringify(response.value)}`);
+			process.exitCode = 1;
+		}
+
+		return;
+	}
+
+	console.info(`Locale added: ${code}`);
+}
+
+async function addStandardLocale(repo: string, code: string) {
+	const url = new URL("/app/settings/multilanguages", await getRepoUrl(repo));
+	return await request(url, {
+		method: "POST",
+		body: { languages: [code] },
+	});
+}
+
+async function addCustomLocale(repo: string, code: string, name: string) {
+	const [langPart, regionPart] = code.split("-");
+	const url = new URL("/app/settings/multilanguages/custom", await getRepoUrl(repo));
+	return await request(url, {
+		method: "POST",
+		body: {
+			lang: { label: name, id: langPart || code },
+			region: { label: name, id: regionPart || langPart || code },
+		},
+	});
+}
+
+function handleUnauthenticated() {
+	console.error("Not logged in. Run `prismic login` first.");
+	process.exitCode = 1;
+}