prismic 0.0.0-canary.169f5fa

package/src/clients/auth.ts

@@ -0,0 +1,36 @@
+import * as v from "valibot";
+
+import { env } from "../env";
+import { request } from "../lib/request";
+
+export async function validateToken(
+	token: string,
+	config: { host: string | undefined },
+): Promise<boolean> {
+	const { host } = config;
+	const authServiceUrl = getAuthServiceUrl(host);
+	const url = new URL("validate", authServiceUrl);
+	url.searchParams.set("token", token);
+	try {
+		await request(url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function refreshToken(
+	token: string,
+	config: { host: string | undefined },
+): Promise<string> {
+	const { host } = config;
+	const authServiceUrl = getAuthServiceUrl(host);
+	const url = new URL("refreshtoken", authServiceUrl);
+	url.searchParams.set("token", token);
+	const refreshedToken = await request(url, { schema: v.string() });
+	return refreshedToken;
+}
+
+function getAuthServiceUrl(host = env.PRISMIC_HOST): URL {
+	return new URL(`https://auth.${host}/`);
+}

package/src/clients/custom-types.ts

@@ -0,0 +1,36 @@
+import type { CustomType, SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+
+import { env } from "../env";
+import { request } from "../lib/request";
+
+export async function getCustomTypes(config: {
+	repo: string;
+	token: string | undefined;
+	host: string | undefined;
+}): Promise<CustomType[]> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL("customtypes", customTypesServiceUrl);
+	const response = await request<CustomType[]>(url, {
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+	});
+	return response;
+}
+
+export async function getSlices(config: {
+	repo: string;
+	token: string | undefined;
+	host: string | undefined;
+}): Promise<SharedSlice[]> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL("slices", customTypesServiceUrl);
+	const response = await request<SharedSlice[]>(url, {
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+	});
+	return response;
+}
+
+function getCustomTypesServiceUrl(host = env.PRISMIC_HOST): URL {
+	return new URL(`https://customtypes.${host}/`);
+}

package/src/clients/user.ts

@@ -0,0 +1,35 @@
+import * as v from "valibot";
+
+import { env } from "../env";
+import { request } from "../lib/request";
+
+const ProfileSchema = v.object({
+	email: v.string(),
+	shortId: v.string(),
+	intercomHash: v.string(),
+	repositories: v.array(
+		v.object({
+			domain: v.string(),
+			name: v.optional(v.string()),
+		}),
+	),
+});
+export type Profile = v.InferOutput<typeof ProfileSchema>;
+
+export async function getProfile(config: {
+	token: string | undefined;
+	host: string | undefined;
+}): Promise<Profile> {
+	const { token, host } = config;
+	const userServiceUrl = getUserServiceUrl(host);
+	const url = new URL("profile", userServiceUrl);
+	const response = await request(url, {
+		credentials: { "prismic-auth": token },
+		schema: ProfileSchema,
+	});
+	return response;
+}
+
+function getUserServiceUrl(host = env.PRISMIC_HOST): URL {
+	return new URL(`https://user-service.${host}/`);
+}

package/src/commands/init.ts

@@ -0,0 +1,162 @@
+import { readFile, rm } from "node:fs/promises";
+import { parseArgs } from "node:util";
+
+import type { Profile } from "../clients/user";
+import type { FrameworkAdapter } from "../frameworks";
+import type { Config } from "../lib/config";
+
+import { getProfile } from "../clients/user";
+import { NoSupportedFrameworkError, requireFramework } from "../frameworks";
+import { createLoginSession, getHost, getToken } from "../lib/auth";
+import { openBrowser } from "../lib/browser";
+import { createConfig, readConfig, UnknownProjectRoot } from "../lib/config";
+import { findUpward } from "../lib/file";
+import { ForbiddenRequestError, UnauthorizedRequestError } from "../lib/request";
+import { syncCustomTypes, syncSlices } from "./sync";
+
+const HELP = `
+Initialize a Prismic project by creating a prismic.config.json file.
+
+Detects the project framework, installs dependencies, and syncs models
+from Prismic. If a slicemachine.config.json exists, it will be migrated.
+
+USAGE
+  prismic init [flags]
+
+FLAGS
+  -r, --repo string   Repository name
+  -h, --help          Show help for command
+
+EXAMPLES
+  prismic init --repo my-repo
+
+LEARN MORE
+  Use \`prismic <command> --help\` for more information about a command.
+`.trim();
+
+export async function init(): Promise<void> {
+	const { values } = parseArgs({
+		args: process.argv.slice(3),
+		options: {
+			help: { type: "boolean", short: "h" },
+			repo: { type: "string", short: "r" },
+		},
+	});
+
+	if (values.help) {
+		console.info(HELP);
+		return;
+	}
+
+	// Check for existing prismic.config.json
+	const existingConfig = await readConfig();
+	if (existingConfig.ok) {
+		console.error("A prismic.config.json file already exists.");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Check for legacy slicemachine.config.json
+	const legacyConfigPath = await findUpward("slicemachine.config.json", {
+		stop: "package.json",
+	});
+	let legacyRepoName: string | undefined;
+	let legacyLibraries: string[] | undefined;
+
+	if (legacyConfigPath) {
+		try {
+			const contents = await readFile(legacyConfigPath, "utf8");
+			const legacyConfig = JSON.parse(contents);
+			legacyRepoName = legacyConfig.repositoryName;
+			legacyLibraries = legacyConfig.libraries;
+		} catch {
+			console.warn("Could not read slicemachine.config.json, ignoring.");
+		}
+	}
+
+	// Determine repo name: --repo flag > legacy config > error
+	const repo = values.repo ?? legacyRepoName;
+	if (!repo) {
+		console.error("Missing required flag: --repo");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Validate repo membership
+	const token = await getToken();
+	const host = await getHost();
+	let profile: Profile;
+	try {
+		profile = await getProfile({ token, host });
+	} catch (error) {
+		if (error instanceof UnauthorizedRequestError || error instanceof ForbiddenRequestError) {
+			console.info("Not logged in. Starting login...");
+			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 as ${email}`);
+		}
+		throw error;
+	}
+
+	const repoMeta = profile.repositories.find((repository) => repository.domain === repo);
+	if (!repoMeta) {
+		console.error(
+			`Repository "${repo}" not found in your account. Check the name or create it with \`prismic repo create\`.`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	let framework: FrameworkAdapter;
+	try {
+		framework = await requireFramework();
+	} catch (error) {
+		if (error instanceof NoSupportedFrameworkError) {
+			console.error(error.message);
+			process.exitCode = 1;
+			return;
+		}
+		throw error;
+	}
+
+	// Create prismic.config.json
+	const configData: Config = { repositoryName: repo };
+	if (legacyLibraries?.length) {
+		configData.libraries = legacyLibraries;
+	}
+
+	const configResult = await createConfig(configData);
+	if (!configResult.ok) {
+		if (configResult.error instanceof UnknownProjectRoot) {
+			console.error(
+				"Could not find a package.json file. Run this command from a project directory.",
+			);
+		} else {
+			console.error("Failed to create config file.");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	// Delete legacy config after new config is created
+	if (legacyConfigPath) {
+		await rm(legacyConfigPath);
+		console.info("Migrated slicemachine.config.json to prismic.config.json");
+	}
+
+	// Install dependencies and create framework files
+	await framework.initProject();
+
+	// Sync models from remote
+	await syncSlices(repo, framework);
+	await syncCustomTypes(repo, framework);
+
+	console.info(
+		`Initialized Prismic for repository "${repo}". Run \`npm install\` to install new dependencies.`,
+	);
+}

package/src/commands/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/commands/logout.ts

@@ -0,0 +1,36 @@
+import { parseArgs } from "node:util";
+
+import { logout as baseLogout } 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 baseLogout();
+	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/commands/sync.ts

@@ -0,0 +1,256 @@
+import { createHash } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { parseArgs } from "node:util";
+
+import { getCustomTypes, getSlices } from "../clients/custom-types";
+import { type FrameworkAdapter, NoSupportedFrameworkError, requireFramework } from "../frameworks";
+import { getHost, getToken } from "../lib/auth";
+import { safeGetRepositoryFromConfig } from "../lib/config";
+import { segmentSetRepository, segmentTrackEnd, segmentTrackStart } from "../lib/segment";
+import { sentrySetContext, sentrySetTag } from "../lib/sentry";
+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;
+	}
+
+	// Override analytics repository context with the resolved repo
+	segmentSetRepository(repo);
+	sentrySetTag("repository", repo);
+	sentrySetContext("Repository Data", { name: repo });
+
+	let framework: FrameworkAdapter;
+	try {
+		framework = await requireFramework();
+	} catch (error) {
+		if (error instanceof NoSupportedFrameworkError) {
+			console.error(error.message);
+			process.exitCode = 1;
+			return;
+		}
+		throw error;
+	}
+
+	console.info(`Syncing from repository: ${repo}`);
+
+	segmentTrackStart("sync", { repository: repo });
+
+	if (watch) {
+		await watchForChanges(repo, framework);
+	} else {
+		await syncSlices(repo, framework);
+		await syncCustomTypes(repo, framework);
+		segmentTrackEnd("sync", true, undefined, { watch: false });
+
+		console.info("Sync complete");
+	}
+}
+
+async function watchForChanges(repo: string, framework: FrameworkAdapter) {
+	const token = await getToken();
+	const host = await getHost();
+
+	const initialRemoteSlices = await getSlices({ repo, token, host });
+	const initialRemoteCustomTypes = await getCustomTypes({ repo, token, host });
+
+	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\n
+	`);
+
+	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 getSlices({ repo, token, host });
+			const remoteSlicesHash = hash(remoteSlicesResult);
+			const slicesChanged = remoteSlicesHash !== lastRemoteSlicesHash;
+
+			const remoteCustomTypesResult = await getCustomTypes({ repo, token, host });
+			const remoteCustomTypesHash = hash(remoteCustomTypesResult);
+			const customTypesChanged = remoteCustomTypesHash !== lastRemoteCustomTypesHash;
+
+			if (slicesChanged || customTypesChanged) {
+				const changed = [];
+
+				if (slicesChanged) {
+					await syncSlices(repo, framework);
+					lastRemoteSlicesHash = remoteSlicesHash;
+					changed.push("slices");
+				}
+				if (customTypesChanged) {
+					await syncCustomTypes(repo, framework);
+					lastRemoteCustomTypesHash = remoteCustomTypesHash;
+					changed.push("custom types");
+				}
+
+				const timestamp = new Date().toLocaleTimeString();
+				console.info(`[${timestamp}] Changes detected in ${changed.join(" and ")}`);
+			}
+
+			// 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 token = await getToken();
+	const host = await getHost();
+
+	const remoteSlices = await getSlices({ repo, token, host });
+	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 token = await getToken();
+	const host = await getHost();
+
+	const remoteCustomTypes = await getCustomTypes({ repo, token, host });
+	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!");
+	segmentTrackEnd("sync", true, undefined, { watch: 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/commands/whoami.ts

@@ -0,0 +1,37 @@
+import { parseArgs } from "node:util";
+
+import { getProfile } from "../clients/user";
+import { getHost, getToken } from "../lib/auth";
+
+const HELP = `
+Show the currently logged in user.
+
+USAGE
+  prismic whoami [flags]
+
+FLAGS
+  -h, --help   Show help for command
+
+LEARN MORE
+  Use \`prismic <command> --help\` for more information about a command.
+`.trim();
+
+export async function whoami(): Promise<void> {
+	const {
+		values: { help },
+	} = parseArgs({
+		args: process.argv.slice(3),
+		options: { help: { type: "boolean", short: "h" } },
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	const token = await getToken();
+	const host = await getHost();
+	const profile = await getProfile({ token, host });
+
+	console.info(profile.email);
+}

package/src/env.ts

@@ -0,0 +1,23 @@
+import * as v from "valibot";
+
+const Env = v.object({
+	MODE: v.string(),
+	DEV: v.boolean(),
+	PROD: v.boolean(),
+	PRISMIC_SENTRY_DSN: v.optional(v.string()),
+	PRISMIC_SENTRY_ENVIRONMENT: v.optional(v.string()),
+	PRISMIC_SENTRY_ENABLED: v.optional(
+		v.pipe(
+			v.picklist(["true", "false"]),
+			v.transform((input) => input === "true"),
+		),
+	),
+	PRISMIC_HOST: v.optional(v.string(), "prismic.io"),
+});
+
+export const env = v.parse(Env, {
+	MODE: process.env.MODE,
+	DEV: process.env.MODE !== "production",
+	PROD: process.env.MODE === "production",
+	...process.env,
+});