prismic 0.0.0-canary.2cfb4a8

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/login.ts

@@ -0,0 +1,45 @@
+import { exec } from "node:child_process";
+import { parseArgs } from "node:util";
+
+import { createLoginSession } from "./lib/auth";
+
+const HELP = `
+Log in to Prismic via browser.
+
+USAGE
+  prismic login [flags]
+
+FLAGS
+  -h, --help   Show help for command
+
+LEARN MORE
+  Use \`prismic <command> --help\` for more information about a command.
+`.trim();
+
+export async function login(): Promise<void> {
+	const { values } = parseArgs({
+		args: process.argv.slice(3),
+		options: { help: { type: "boolean", short: "h" } },
+	});
+
+	if (values.help) {
+		console.info(HELP);
+		return;
+	}
+
+	const { email } = await createLoginSession({
+		onReady: (url) => {
+			console.info("Opening browser to complete login...");
+			console.info(`If the browser doesn't open, visit: ${url}`);
+			openBrowser(url);
+		},
+	});
+
+	console.info(`Logged in to Prismic as ${email}`);
+}
+
+function openBrowser(url: URL): void {
+	const cmd =
+		process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+	exec(`${cmd} "${url.toString()}"`);
+}

package/src/logout.ts

@@ -0,0 +1,36 @@
+import { parseArgs } from "node:util";
+
+import { removeToken } from "./lib/auth";
+
+const HELP = `
+Log out of Prismic.
+
+USAGE
+  prismic logout [flags]
+
+FLAGS
+  -h, --help   Show help for command
+
+LEARN MORE
+  Use \`prismic <command> --help\` for more information about a command.
+`.trim();
+
+export async function logout(): Promise<void> {
+	const { values } = parseArgs({
+		args: process.argv.slice(3),
+		options: { help: { type: "boolean", short: "h" } },
+	});
+
+	if (values.help) {
+		console.info(HELP);
+		return;
+	}
+
+	const ok = await removeToken();
+	if (ok) {
+		console.info("Logged out of Prismic");
+	} else {
+		console.error("Logout failed. You can log out manually by deleting the file.");
+		process.exitCode = 1;
+	}
+}

package/src/sync.ts

@@ -0,0 +1,259 @@
+import { createHash } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { parseArgs } from "node:util";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { fetchRemoteCustomTypes, fetchRemoteSlices } from "./lib/custom-types-api";
+import { type FrameworkAdapter, getFramework } from "./framework";
+import { trackEnd } from "./lib/segment";
+import { dedent } from "./lib/string";
+
+const HELP = `
+Sync slices, page types, and custom types from Prismic to local files.
+
+Remote models are the source of truth. Local files are created, updated,
+or deleted to match.
+
+USAGE
+  prismic sync [flags]
+
+FLAGS
+  -r, --repo string   Repository domain
+  -w, --watch         Watch for changes and sync continuously
+  -h, --help          Show help for command
+`.trim();
+
+// 5 seconds balances responsiveness with API load
+const POLL_INTERVAL_MS = 5000;
+const MAX_BACKOFF_MS = 60000; // Cap backoff at 1 minute
+const MAX_CONSECUTIVE_ERRORS = 10;
+
+export async function sync(): Promise<void> {
+	const {
+		values: { help, repo = await safeGetRepositoryFromConfig(), watch },
+	} = parseArgs({
+		args: process.argv.slice(3), // skip: node, script, "sync"
+		options: {
+			repo: { type: "string", short: "r" },
+			watch: { type: "boolean", short: "w" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: false,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!repo) {
+		console.error("Missing prismic.config.json or --repo option");
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!(await isAuthenticated())) {
+		console.error("Not logged in. Run `prismic login` first.");
+		process.exitCode = 1;
+		return;
+	}
+
+	const framework = await getFramework();
+	if (!framework) {
+		console.error("Could not detect a supported framework (Next.js, Nuxt, or SvelteKit).");
+		process.exitCode = 1;
+		return;
+	}
+
+	console.info(`Syncing from repository: ${repo}`);
+
+	if (watch) {
+		await watchForChanges(repo, framework);
+	} else {
+		await syncSlices(repo, framework);
+		await syncCustomTypes(repo, framework);
+
+		console.info("Sync complete");
+	}
+}
+
+async function watchForChanges(repo: string, framework: FrameworkAdapter) {
+	const remoteSlicesResult = await fetchRemoteSlices(repo);
+	if (!remoteSlicesResult.ok) {
+		console.error(`Failed to fetch remote slices: ${remoteSlicesResult.error}`);
+		process.exitCode = 1;
+		return;
+	}
+	const initialRemoteSlices = remoteSlicesResult.value;
+
+	const remoteCustomTypesResult = await fetchRemoteCustomTypes(repo);
+	if (!remoteCustomTypesResult.ok) {
+		console.error(`Failed to fetch remote custom types: ${remoteCustomTypesResult.error}`);
+		process.exitCode = 1;
+		return;
+	}
+	const initialRemoteCustomTypes = remoteCustomTypesResult.value;
+
+	await syncSlices(repo, framework);
+	await syncCustomTypes(repo, framework);
+
+	console.info(dedent`
+		Initial sync completed!
+
+		Watching for changes (polling every ${POLL_INTERVAL_MS / 1000}s),
+		Press Ctrl+C to stop
+	`);
+
+	let lastRemoteSlicesHash = hash(initialRemoteSlices);
+	let lastRemoteCustomTypesHash = hash(initialRemoteCustomTypes);
+
+	let consecutiveErrors = 0;
+
+	// Handle all common termination signals
+	process.on("SIGINT", shutdown); // Ctrl+C
+	process.on("SIGTERM", shutdown); // kill command
+	process.on("SIGHUP", shutdown); // terminal closed
+	process.on("SIGQUIT", shutdown); // Ctrl+\
+	if (process.platform === "win32") {
+		process.on("SIGBREAK", shutdown); // Windows Ctrl+Break
+	}
+
+	while (true) {
+		await setTimeout(exponentialMs(consecutiveErrors));
+
+		try {
+			const remoteSlicesResult = await fetchRemoteSlices(repo);
+			if (!remoteSlicesResult.ok) continue;
+			const remoteSlicesHash = hash(remoteSlicesResult.value);
+			const slicesChanged = remoteSlicesHash !== lastRemoteSlicesHash;
+
+			const remoteCustomTypesResult = await fetchRemoteCustomTypes(repo);
+			if (!remoteCustomTypesResult.ok) continue;
+			const remoteCustomTypesHash = hash(remoteCustomTypesResult.value);
+			const customTypesChanged = remoteCustomTypesHash !== lastRemoteCustomTypesHash;
+
+			if (slicesChanged || customTypesChanged) {
+				if (slicesChanged) {
+					await syncSlices(repo, framework);
+					lastRemoteSlicesHash = remoteSlicesHash;
+				}
+				if (customTypesChanged) {
+					await syncCustomTypes(repo, framework);
+					lastRemoteCustomTypesHash = remoteCustomTypesHash;
+				}
+			}
+
+			// Reset error count on success
+			consecutiveErrors = 0;
+		} catch (error) {
+			consecutiveErrors++;
+
+			const message = error instanceof Error ? error.message : "Unknown error";
+
+			const nextDelay = Math.min(
+				POLL_INTERVAL_MS * Math.pow(2, consecutiveErrors - 1),
+				MAX_BACKOFF_MS,
+			);
+
+			console.error(`Error checking for changes: ${message}. Retrying in ${nextDelay / 1000}s...`);
+
+			if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+				throw new Error(`Too many consecutive errors (${MAX_CONSECUTIVE_ERRORS}), stopping watch.`);
+			}
+		}
+	}
+}
+
+export async function syncSlices(repo: string, framework: FrameworkAdapter): Promise<void> {
+	const remoteSlicesResult = await fetchRemoteSlices(repo);
+	if (!remoteSlicesResult.ok) {
+		console.error(`Failed to fetch remote slices: ${remoteSlicesResult.error}`);
+		process.exitCode = 1;
+		return;
+	}
+	const remoteSlices = remoteSlicesResult.value;
+	const localSlices = await framework.getSlices();
+
+	// Handle slices update
+	for (const remoteSlice of remoteSlices) {
+		const localSlice = localSlices.find((slice) => slice.model.id === remoteSlice.id);
+		if (localSlice) {
+			await framework.updateSlice(remoteSlice);
+		}
+	}
+
+	// Handle slices deletion
+	for (const localSlice of localSlices) {
+		const existsRemotely = remoteSlices.some((slice) => slice.id === localSlice.model.id);
+		if (!existsRemotely) {
+			await framework.deleteSlice(localSlice.model.id);
+		}
+	}
+
+	// Handle slices creation
+	const defaultLibrary = await framework.getDefaultSliceLibrary();
+	for (const remoteSlice of remoteSlices) {
+		const existsLocally = localSlices.some((slice) => slice.model.id === remoteSlice.id);
+		if (!existsLocally) {
+			await framework.createSlice(remoteSlice, defaultLibrary);
+		}
+	}
+}
+
+export async function syncCustomTypes(repo: string, framework: FrameworkAdapter): Promise<void> {
+	const remoteCustomTypesResult = await fetchRemoteCustomTypes(repo);
+	if (!remoteCustomTypesResult.ok) {
+		console.error(`Failed to fetch remote custom types: ${remoteCustomTypesResult.error}`);
+		process.exitCode = 1;
+		return;
+	}
+	const remoteCustomTypes = remoteCustomTypesResult.value;
+	const localCustomTypes = await framework.getCustomTypes();
+
+	// Handle custom types update
+	for (const remoteCustomType of remoteCustomTypes) {
+		const localCustomType = localCustomTypes.find(
+			(customType) => customType.model.id === remoteCustomType.id,
+		);
+		if (localCustomType) {
+			await framework.updateCustomType(remoteCustomType);
+		}
+	}
+
+	// Handle custom types deletion
+	for (const localCustomType of localCustomTypes) {
+		const existsRemotely = remoteCustomTypes.some(
+			(customType) => customType.id === localCustomType.model.id,
+		);
+		if (!existsRemotely) {
+			await framework.deleteCustomType(localCustomType.model.id);
+		}
+	}
+
+	// Handle custom types creation
+	for (const remoteCustomType of remoteCustomTypes) {
+		const existsLocally = localCustomTypes.some(
+			(customType) => customType.model.id === remoteCustomType.id,
+		);
+		if (!existsLocally) {
+			await framework.createCustomType(remoteCustomType);
+		}
+	}
+}
+
+function shutdown(): void {
+	console.info("Watch stopped. Goodbye!");
+	trackEnd("sync", true);
+	process.exit(0);
+}
+
+// Exponential backoff: 5s, 10s, 20s, 40s, 60s (capped)
+function exponentialMs(base: number): number {
+	if (base === 0) return POLL_INTERVAL_MS;
+	return Math.min(POLL_INTERVAL_MS * Math.pow(2, base - 1), MAX_BACKOFF_MS);
+}
+
+function hash(data: unknown): string {
+	return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+}