prismic 0.0.0-pr.28.59bf330

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");
+}

package/src/token-create.ts

@@ -0,0 +1,203 @@
+import { parseArgs } from "node:util";
+import * as v from "valibot";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { stringify } from "./lib/json";
+import { ForbiddenRequestError, request, UnauthorizedRequestError } from "./lib/request";
+import { getRepoUrl } from "./lib/url";
+import {
+	type AccessToken,
+	AccessTokenSchema,
+	getAccessTokens,
+	type OAuthApp,
+	OAuthAppSchema,
+	type WriteToken,
+	WriteTokenSchema,
+} from "./token-list";
+
+const HELP = `
+Create a new API token for a Prismic repository.
+
+By default, this command reads the repository from prismic.config.json at the
+project root.
+
+USAGE
+  prismic token create [flags]
+
+FLAGS
+  -w, --write              Create a write token (Custom Types/Migration API)
+  -n, --name string        Token name (default: "Prismic CLI")
+      --allow-releases     Allow access to releases (access tokens only)
+      --json               Output as JSON
+  -r, --repo string        Repository domain
+  -h, --help               Show help for command
+
+LEARN MORE
+  Use \`prismic token <command> --help\` for more information about a command.
+`.trim();
+
+const DEFAULT_APP_NAME = "Prismic CLI";
+
+export async function tokenCreate(): Promise<void> {
+	const {
+		values: {
+			help,
+			repo = await safeGetRepositoryFromConfig(),
+			json,
+			write,
+			name = DEFAULT_APP_NAME,
+			"allow-releases": allowReleases,
+		},
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "token", "create"
+		options: {
+			json: { type: "boolean" },
+			repo: { type: "string", short: "r" },
+			help: { type: "boolean", short: "h" },
+			write: { type: "boolean", short: "w" },
+			name: { type: "string", short: "n" },
+			"allow-releases": { type: "boolean" },
+		},
+		allowPositionals: false,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!repo) {
+		console.error("Missing prismic.config.json or --repo option");
+		process.exitCode = 1;
+		return;
+	}
+
+	if (write && allowReleases) {
+		console.error("--allow-releases is only valid for access tokens (not with --write)");
+		process.exitCode = 1;
+		return;
+	}
+
+	const authenticated = await isAuthenticated();
+	if (!authenticated) {
+		handleUnauthenticated();
+		return;
+	}
+
+	if (write) {
+		const result = await createWriteToken(repo, name);
+		if (!result.ok) {
+			if (
+				result.error instanceof ForbiddenRequestError ||
+				result.error instanceof UnauthorizedRequestError
+			) {
+				handleUnauthenticated();
+			} else if (v.isValiError(result.error)) {
+				console.error(
+					`Failed to create write token: Invalid response: ${stringify(result.error.issues)}`,
+				);
+				process.exitCode = 1;
+			} else {
+				console.error(`Failed to create write token: ${stringify(result.value)}`);
+				process.exitCode = 1;
+			}
+			return;
+		}
+
+		if (json) {
+			console.info(stringify(result.value));
+		} else {
+			console.info(`Token created: ${result.value.token}`);
+		}
+	} else {
+		const scope = allowReleases ? "master+releases" : "master";
+		const result = await createAccessToken(repo, name, scope);
+		if (!result.ok) {
+			if (
+				result.error instanceof ForbiddenRequestError ||
+				result.error instanceof UnauthorizedRequestError
+			) {
+				handleUnauthenticated();
+			} else if (v.isValiError(result.error)) {
+				console.error(
+					`Failed to create access token: Invalid response: ${stringify(result.error.issues)}`,
+				);
+				process.exitCode = 1;
+			} else {
+				console.error(`Failed to create access token: ${stringify(result.value)}`);
+				process.exitCode = 1;
+			}
+			return;
+		}
+
+		if (json) {
+			console.info(stringify(result.value));
+		} else {
+			console.info(`Token created: ${result.value.token}`);
+		}
+	}
+}
+
+type CreateWriteTokenResult =
+	| { ok: true; value: WriteToken }
+	| { ok: false; value: unknown; error: Error | v.ValiError<typeof WriteTokenSchema> };
+
+async function createWriteToken(repo: string, appName: string): Promise<CreateWriteTokenResult> {
+	const url = new URL("settings/security/token", await getRepoUrl(repo));
+	const response = await request(url, {
+		method: "POST",
+		body: { app_name: appName },
+		schema: WriteTokenSchema,
+	});
+	return response;
+}
+
+type CreateAccessTokenResult =
+	| { ok: true; value: AccessToken }
+	| { ok: false; value: unknown; error: Error | v.ValiError<typeof AccessTokenSchema> };
+
+async function createAccessToken(
+	repo: string,
+	appName: string,
+	scope: "master" | "master+releases",
+): Promise<CreateAccessTokenResult> {
+	// First, find or create an OAuth app with the given name
+	const appsResponse = await getAccessTokens(repo);
+	if (!appsResponse.ok) {
+		return appsResponse;
+	}
+
+	let app = appsResponse.value.find((a: OAuthApp) => a.name === appName);
+
+	// Create OAuth app if it doesn't exist
+	if (!app) {
+		const createAppUrl = new URL("settings/security/oauthapp", await getRepoUrl(repo));
+		const createAppResponse = await request(createAppUrl, {
+			method: "POST",
+			body: { app_name: appName },
+			schema: OAuthAppSchema,
+		});
+
+		if (!createAppResponse.ok) {
+			return createAppResponse;
+		}
+
+		app = createAppResponse.value;
+	}
+
+	// Create the authorization token
+	const authUrl = new URL("settings/security/authorizations", await getRepoUrl(repo));
+	const authResponse = await request(authUrl, {
+		method: "POST",
+		body: { app: app.id, scope },
+		schema: AccessTokenSchema,
+	});
+
+	return authResponse;
+}
+
+function handleUnauthenticated(): void {
+	console.error("Not logged in. Run `prismic login` first.");
+	process.exitCode = 1;
+}

package/src/token-delete.ts

@@ -0,0 +1,182 @@
+import { parseArgs } from "node:util";
+import * as v from "valibot";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { stringify } from "./lib/json";
+import { ForbiddenRequestError, request, UnauthorizedRequestError } from "./lib/request";
+import { getRepoUrl } from "./lib/url";
+import { type AccessToken, getAccessTokens, getWriteTokens, type WriteToken } from "./token-list";
+
+const HELP = `
+Delete a token from a Prismic repository.
+
+By default, this command reads the repository from prismic.config.json at the
+project root.
+
+USAGE
+  prismic token delete <token> [flags]
+
+ARGUMENTS
+  token   The token value (or partial match)
+
+FLAGS
+  -r, --repo string   Repository domain
+  -h, --help          Show help for command
+
+LEARN MORE
+  Use \`prismic token <command> --help\` for more information about a command.
+`.trim();
+
+export async function tokenDelete(): Promise<void> {
+	const {
+		values: { help, repo = await safeGetRepositoryFromConfig() },
+		positionals: [tokenValue],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "token", "delete"
+		options: {
+			repo: { type: "string", short: "r" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!tokenValue) {
+		console.error("Missing required argument: token");
+		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;
+	}
+
+	// First, find the token in access tokens or write tokens
+	const [accessResponse, writeResponse] = await Promise.all([
+		getAccessTokens(repo),
+		getWriteTokens(repo),
+	]);
+
+	if (!accessResponse.ok) {
+		if (
+			accessResponse.error instanceof ForbiddenRequestError ||
+			accessResponse.error instanceof UnauthorizedRequestError
+		) {
+			handleUnauthenticated();
+		} else if (v.isValiError(accessResponse.error)) {
+			console.error(
+				`Failed to list access tokens: Invalid response: ${stringify(accessResponse.error.issues)}`,
+			);
+			process.exitCode = 1;
+		} else {
+			console.error(`Failed to list access tokens: ${stringify(accessResponse.value)}`);
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	if (!writeResponse.ok) {
+		if (
+			writeResponse.error instanceof ForbiddenRequestError ||
+			writeResponse.error instanceof UnauthorizedRequestError
+		) {
+			handleUnauthenticated();
+		} else if (v.isValiError(writeResponse.error)) {
+			console.error(
+				`Failed to list write tokens: Invalid response: ${stringify(writeResponse.error.issues)}`,
+			);
+			process.exitCode = 1;
+		} else {
+			console.error(`Failed to list write tokens: ${stringify(writeResponse.value)}`);
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	// Find in access tokens
+	let foundAuth: AccessToken | undefined;
+	for (const app of accessResponse.value) {
+		for (const auth of app.wroom_auths) {
+			if (
+				auth.token === tokenValue ||
+				auth.token.startsWith(tokenValue) ||
+				auth.token.endsWith(tokenValue)
+			) {
+				foundAuth = auth;
+				break;
+			}
+		}
+		if (foundAuth) break;
+	}
+
+	if (foundAuth) {
+		// Delete the authorization (preserves OAuth app)
+		const url = new URL(`settings/security/authorizations/${foundAuth.id}`, await getRepoUrl(repo));
+		const response = await request(url, { method: "DELETE" });
+
+		if (!response.ok) {
+			if (
+				response.error instanceof ForbiddenRequestError ||
+				response.error instanceof UnauthorizedRequestError
+			) {
+				handleUnauthenticated();
+			} else {
+				console.error(`Failed to delete token: ${stringify(response.value)}`);
+				process.exitCode = 1;
+			}
+			return;
+		}
+
+		console.info("Token deleted");
+		return;
+	}
+
+	// Find in write tokens
+	const foundWriteToken = writeResponse.value.tokens.find(
+		(t: WriteToken) =>
+			t.token === tokenValue || t.token.startsWith(tokenValue) || t.token.endsWith(tokenValue),
+	);
+
+	if (foundWriteToken) {
+		// Delete write token
+		const url = new URL(`settings/security/token/${foundWriteToken.token}`, await getRepoUrl(repo));
+		const response = await request(url, { method: "DELETE" });
+
+		if (!response.ok) {
+			if (
+				response.error instanceof ForbiddenRequestError ||
+				response.error instanceof UnauthorizedRequestError
+			) {
+				handleUnauthenticated();
+			} else {
+				console.error(`Failed to delete token: ${stringify(response.value)}`);
+				process.exitCode = 1;
+			}
+			return;
+		}
+
+		console.info("Token deleted");
+		return;
+	}
+
+	console.error(`Token not found: ${tokenValue}`);
+	process.exitCode = 1;
+}
+
+function handleUnauthenticated(): void {
+	console.error("Not logged in. Run `prismic login` first.");
+	process.exitCode = 1;
+}