prismic 1.1.0 → 1.2.0

package/src/commands/preview-set-simulator.ts

@@ -0,0 +1,60 @@
+import { getHost, getToken } from "../auth";
+import { setSimulatorUrl } from "../clients/core";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { UnknownRequestError } from "../lib/request";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic preview set-simulator",
+	description: `
+		Set the slice simulator URL for a Prismic repository.
+
+		If the URL pathname does not end with /slice-simulator, it is appended
+		automatically.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	positionals: {
+		url: { description: "Simulator URL (e.g. https://example.com/slice-simulator)" },
+	},
+	options: {
+		repo: { type: "string", short: "r", description: "Repository domain" },
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [urlArg] = positionals;
+	const { repo = await getRepositoryName() } = values;
+
+	if (!urlArg) {
+		throw new CommandError("Missing required argument: <url>");
+	}
+
+	let parsed: URL;
+	try {
+		parsed = new URL(urlArg);
+	} catch {
+		throw new CommandError(`Invalid URL: ${urlArg}`);
+	}
+
+	if (!parsed.pathname.endsWith("/slice-simulator")) {
+		parsed.pathname = parsed.pathname.replace(/\/+$/, "") + "/slice-simulator";
+	}
+	const simulatorUrl = parsed.toString();
+
+	const token = await getToken();
+	const host = await getHost();
+
+	try {
+		await setSimulatorUrl(simulatorUrl, { repo, token, host });
+	} catch (error) {
+		if (error instanceof UnknownRequestError) {
+			const message = await error.text();
+			throw new CommandError(`Failed to set simulator URL: ${message}`);
+		}
+		throw error;
+	}
+
+	console.info(`Simulator URL set: ${simulatorUrl}`);
+});

package/src/commands/preview.ts

@@ -0,0 +1,28 @@
+import { createCommandRouter } from "../lib/command";
+import previewAdd from "./preview-add";
+import previewList from "./preview-list";
+import previewRemove from "./preview-remove";
+import previewSetSimulator from "./preview-set-simulator";
+
+export default createCommandRouter({
+	name: "prismic preview",
+	description: "Manage preview configurations in a Prismic repository.",
+	commands: {
+		add: {
+			handler: previewAdd,
+			description: "Add a preview configuration",
+		},
+		list: {
+			handler: previewList,
+			description: "List preview configurations",
+		},
+		remove: {
+			handler: previewRemove,
+			description: "Remove a preview configuration",
+		},
+		"set-simulator": {
+			handler: previewSetSimulator,
+			description: "Set the slice simulator URL",
+		},
+	},
+});

package/src/commands/sync.ts

@@ -1,103 +1,65 @@
 import { createHash } from "node:crypto";
 import { setTimeout } from "node:timers/promises";
-import { parseArgs } from "node:util";
 
+import { getAdapter, type Adapter } from "../adapters";
 import { getHost, getToken } from "../auth";
 import { getCustomTypes, getSlices } from "../clients/custom-types";
-import { safeGetRepositoryFromConfig } from "../config";
-import { type FrameworkAdapter, NoSupportedFrameworkError, requireFramework } from "../frameworks";
 import { generateAndWriteTypes } from "../lib/codegen";
-import { segmentSetRepository, segmentTrackEnd, segmentTrackStart } from "../lib/segment";
-import { sentrySetContext, sentrySetTag } from "../lib/sentry";
+import { createCommand, type CommandConfig } from "../lib/command";
+import { segmentTrackEnd, segmentTrackStart } 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();
+import { findProjectRoot, getRepositoryName } from "../project";
 
 // 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,
-	});
+const config = {
+	name: "prismic sync",
+	description: `
+		Sync slices, page types, and custom types from Prismic to local files.
 
-	if (help) {
-		console.info(HELP);
-		return;
-	}
+		Remote models are the source of truth. Local files are created, updated,
+		or deleted to match.
+	`,
+	options: {
+		repo: { type: "string", short: "r", description: "Repository domain" },
+		watch: { type: "boolean", short: "w", description: "Watch for changes and sync continuously" },
+	},
+} satisfies CommandConfig;
 
-	if (!repo) {
-		console.error("Missing prismic.config.json or --repo option");
-		process.exitCode = 1;
-		return;
-	}
+export default createCommand(config, async ({ values }) => {
+	const { repo = await getRepositoryName(), watch } = values;
 
-	// 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;
-	}
+	const adapter = await getAdapter();
 
 	console.info(`Syncing from repository: ${repo}`);
 
-	segmentTrackStart("sync", { repository: repo });
+	segmentTrackStart("sync", { watch });
 
 	if (watch) {
-		await watchForChanges(repo, framework);
+		await watchForChanges(repo, adapter);
 	} else {
-		await syncSlices(repo, framework);
-		await syncCustomTypes(repo, framework);
-		await regenerateTypes(framework);
-		segmentTrackEnd("sync", true, undefined, { watch: false });
+		await syncSlices(repo, adapter);
+		await syncCustomTypes(repo, adapter);
+		await regenerateTypes(adapter);
+		segmentTrackEnd("sync", { watch });
 
 		console.info("Sync complete");
 	}
-}
+});
 
-async function watchForChanges(repo: string, framework: FrameworkAdapter) {
+async function watchForChanges(repo: string, adapter: Adapter) {
 	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);
-	await regenerateTypes(framework);
+	await syncSlices(repo, adapter);
+	await syncCustomTypes(repo, adapter);
+	await regenerateTypes(adapter);
 
 	console.info(dedent`
 		Initial sync completed!
@@ -136,17 +98,17 @@ async function watchForChanges(repo: string, framework: FrameworkAdapter) {
 				const changed = [];
 
 				if (slicesChanged) {
-					await syncSlices(repo, framework);
+					await syncSlices(repo, adapter);
 					lastRemoteSlicesHash = remoteSlicesHash;
 					changed.push("slices");
 				}
 				if (customTypesChanged) {
-					await syncCustomTypes(repo, framework);
+					await syncCustomTypes(repo, adapter);
 					lastRemoteCustomTypesHash = remoteCustomTypesHash;
 					changed.push("custom types");
 				}
 
-				await regenerateTypes(framework);
+				await regenerateTypes(adapter);
 
 				const timestamp = new Date().toLocaleTimeString();
 				console.info(`[${timestamp}] Changes detected in ${changed.join(" and ")}`);
@@ -173,18 +135,18 @@ async function watchForChanges(repo: string, framework: FrameworkAdapter) {
 	}
 }
 
-export async function syncSlices(repo: string, framework: FrameworkAdapter): Promise<void> {
+export async function syncSlices(repo: string, adapter: Adapter): Promise<void> {
 	const token = await getToken();
 	const host = await getHost();
 
 	const remoteSlices = await getSlices({ repo, token, host });
-	const localSlices = await framework.getSlices();
+	const localSlices = await adapter.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);
+			await adapter.updateSlice(remoteSlice);
 		}
 	}
 
@@ -192,26 +154,26 @@ export async function syncSlices(repo: string, framework: FrameworkAdapter): Pro
 	for (const localSlice of localSlices) {
 		const existsRemotely = remoteSlices.some((slice) => slice.id === localSlice.model.id);
 		if (!existsRemotely) {
-			await framework.deleteSlice(localSlice.model.id);
+			await adapter.deleteSlice(localSlice.model.id);
 		}
 	}
 
 	// Handle slices creation
-	const defaultLibrary = await framework.getDefaultSliceLibrary();
+	const defaultLibrary = await adapter.getDefaultSliceLibrary();
 	for (const remoteSlice of remoteSlices) {
 		const existsLocally = localSlices.some((slice) => slice.model.id === remoteSlice.id);
 		if (!existsLocally) {
-			await framework.createSlice(remoteSlice, defaultLibrary);
+			await adapter.createSlice(remoteSlice, defaultLibrary);
 		}
 	}
 }
 
-export async function syncCustomTypes(repo: string, framework: FrameworkAdapter): Promise<void> {
+export async function syncCustomTypes(repo: string, adapter: Adapter): Promise<void> {
 	const token = await getToken();
 	const host = await getHost();
 
 	const remoteCustomTypes = await getCustomTypes({ repo, token, host });
-	const localCustomTypes = await framework.getCustomTypes();
+	const localCustomTypes = await adapter.getCustomTypes();
 
 	// Handle custom types update
 	for (const remoteCustomType of remoteCustomTypes) {
@@ -219,7 +181,7 @@ export async function syncCustomTypes(repo: string, framework: FrameworkAdapter)
 			(customType) => customType.model.id === remoteCustomType.id,
 		);
 		if (localCustomType) {
-			await framework.updateCustomType(remoteCustomType);
+			await adapter.updateCustomType(remoteCustomType);
 		}
 	}
 
@@ -229,7 +191,7 @@ export async function syncCustomTypes(repo: string, framework: FrameworkAdapter)
 			(customType) => customType.id === localCustomType.model.id,
 		);
 		if (!existsRemotely) {
-			await framework.deleteCustomType(localCustomType.model.id);
+			await adapter.deleteCustomType(localCustomType.model.id);
 		}
 	}
 
@@ -239,14 +201,14 @@ export async function syncCustomTypes(repo: string, framework: FrameworkAdapter)
 			(customType) => customType.model.id === remoteCustomType.id,
 		);
 		if (!existsLocally) {
-			await framework.createCustomType(remoteCustomType);
+			await adapter.createCustomType(remoteCustomType);
 		}
 	}
 }
 
 function shutdown(): void {
 	console.info("Watch stopped. Goodbye!");
-	segmentTrackEnd("sync", true, undefined, { watch: true });
+	segmentTrackEnd("sync", { watch: true });
 	process.exit(0);
 }
 
@@ -260,10 +222,10 @@ function hash(data: unknown): string {
 	return createHash("sha256").update(JSON.stringify(data)).digest("hex");
 }
 
-async function regenerateTypes(framework: FrameworkAdapter): Promise<void> {
-	const slices = await framework.getSlices();
-	const customTypes = await framework.getCustomTypes();
-	const projectRoot = await framework.getProjectRoot();
+async function regenerateTypes(adapter: Adapter): Promise<void> {
+	const slices = await adapter.getSlices();
+	const customTypes = await adapter.getCustomTypes();
+	const projectRoot = await findProjectRoot();
 	await generateAndWriteTypes({
 		customTypes: customTypes.map((customType) => customType.model),
 		slices: slices.map((slice) => slice.model),

package/src/commands/webhook-create.ts

@@ -0,0 +1,89 @@
+import { getHost, getToken } from "../auth";
+import { createWebhook, WEBHOOK_TRIGGERS } from "../clients/wroom";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { UnknownRequestError } from "../lib/request";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic webhook create",
+	description: `
+		Create a new webhook in a Prismic repository.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	positionals: {
+		url: { description: "Webhook URL to receive events" },
+	},
+	options: {
+		name: { type: "string", short: "n", description: "Webhook name" },
+		secret: { type: "string", short: "s", description: "Secret for webhook signature" },
+		trigger: {
+			type: "string",
+			multiple: true,
+			short: "t",
+			description: "Trigger events (can be repeated)",
+		},
+		repo: { type: "string", short: "r", description: "Repository domain" },
+	},
+	sections: {
+		TRIGGERS: `
+			documentsPublished    When documents are published
+			documentsUnpublished  When documents are unpublished
+			releasesCreated       When a release is created
+			releasesUpdated       When a release is edited or deleted
+			tagsCreated           When a tag is created
+			tagsDeleted           When a tag is deleted
+
+			If no triggers specified, all are enabled.
+		`,
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [webhookUrl] = positionals;
+	const { repo = await getRepositoryName(), name, secret, trigger = [] } = values;
+
+	if (!webhookUrl) {
+		throw new CommandError("Missing required argument: <url>");
+	}
+
+	// Validate triggers
+	for (const t of trigger) {
+		if (!WEBHOOK_TRIGGERS.includes(t)) {
+			throw new CommandError(
+				`Invalid trigger: ${t}\nValid triggers: ${WEBHOOK_TRIGGERS.join(", ")}`,
+			);
+		}
+	}
+
+	const token = await getToken();
+	const host = await getHost();
+
+	const defaultValue = trigger.length > 0 ? false : true;
+
+	try {
+		await createWebhook(
+			{
+				url: webhookUrl,
+				name: name ?? null,
+				secret: secret ?? null,
+				documentsPublished: trigger.includes("documentsPublished") || defaultValue,
+				documentsUnpublished: trigger.includes("documentsUnpublished") || defaultValue,
+				releasesCreated: trigger.includes("releasesCreated") || defaultValue,
+				releasesUpdated: trigger.includes("releasesUpdated") || defaultValue,
+				tagsCreated: trigger.includes("tagsCreated") || defaultValue,
+				tagsDeleted: trigger.includes("tagsDeleted") || defaultValue,
+			},
+			{ repo, token, host },
+		);
+	} catch (error) {
+		if (error instanceof UnknownRequestError) {
+			const message = await error.text();
+			throw new CommandError(`Failed to create webhook: ${message}`);
+		}
+		throw error;
+	}
+
+	console.info(`Webhook created: ${webhookUrl}`);
+});

package/src/commands/webhook-disable.ts

@@ -0,0 +1,60 @@
+import { getHost, getToken } from "../auth";
+import { getWebhooks, updateWebhook } from "../clients/wroom";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { UnknownRequestError } from "../lib/request";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic webhook disable",
+	description: `
+		Disable a webhook in a Prismic repository.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	positionals: {
+		url: { description: "Webhook URL" },
+	},
+	options: {
+		repo: { type: "string", short: "r", description: "Repository domain" },
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [webhookUrl] = positionals;
+	const { repo = await getRepositoryName() } = values;
+
+	if (!webhookUrl) {
+		throw new CommandError("Missing required argument: <url>");
+	}
+
+	const token = await getToken();
+	const host = await getHost();
+	const webhooks = await getWebhooks({ repo, token, host });
+	const webhook = webhooks.find((w) => w.config.url === webhookUrl);
+	if (!webhook) {
+		throw new CommandError(`Webhook not found: ${webhookUrl}`);
+	}
+
+	if (!webhook.config.active) {
+		console.info(`Webhook already disabled: ${webhookUrl}`);
+		return;
+	}
+
+	const id = webhook.config._id;
+
+	const updatedConfig = structuredClone(webhook.config);
+	updatedConfig.active = false;
+
+	try {
+		await updateWebhook(id, updatedConfig, { repo, token, host });
+	} catch (error) {
+		if (error instanceof UnknownRequestError) {
+			const message = await error.text();
+			throw new CommandError(`Failed to disable webhook: ${message}`);
+		}
+		throw error;
+	}
+
+	console.info(`Webhook disabled: ${webhookUrl}`);
+});

package/src/commands/webhook-enable.ts

@@ -0,0 +1,60 @@
+import { getHost, getToken } from "../auth";
+import { getWebhooks, updateWebhook } from "../clients/wroom";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { UnknownRequestError } from "../lib/request";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic webhook enable",
+	description: `
+		Enable a webhook in a Prismic repository.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	positionals: {
+		url: { description: "Webhook URL" },
+	},
+	options: {
+		repo: { type: "string", short: "r", description: "Repository domain" },
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [webhookUrl] = positionals;
+	const { repo = await getRepositoryName() } = values;
+
+	if (!webhookUrl) {
+		throw new CommandError("Missing required argument: <url>");
+	}
+
+	const token = await getToken();
+	const host = await getHost();
+	const webhooks = await getWebhooks({ repo, token, host });
+	const webhook = webhooks.find((w) => w.config.url === webhookUrl);
+	if (!webhook) {
+		throw new CommandError(`Webhook not found: ${webhookUrl}`);
+	}
+
+	if (webhook.config.active) {
+		console.info(`Webhook already enabled: ${webhookUrl}`);
+		return;
+	}
+
+	const id = webhook.config._id;
+
+	const updatedConfig = structuredClone(webhook.config);
+	updatedConfig.active = true;
+
+	try {
+		await updateWebhook(id, updatedConfig, { repo, token, host });
+	} catch (error) {
+		if (error instanceof UnknownRequestError) {
+			const message = await error.text();
+			throw new CommandError(`Failed to enable webhook: ${message}`);
+		}
+		throw error;
+	}
+
+	console.info(`Webhook enabled: ${webhookUrl}`);
+});

package/src/commands/webhook-list.ts

@@ -0,0 +1,43 @@
+import { getHost, getToken } from "../auth";
+import { getWebhooks } from "../clients/wroom";
+import { createCommand, type CommandConfig } from "../lib/command";
+import { stringify } from "../lib/json";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic webhook list",
+	description: `
+		List all webhooks in a Prismic repository.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	options: {
+		json: { type: "boolean", description: "Output as JSON" },
+		repo: { type: "string", short: "r", description: "Repository domain" },
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ values }) => {
+	const { repo = await getRepositoryName(), json } = values;
+
+	const token = await getToken();
+	const host = await getHost();
+	const webhooks = await getWebhooks({ repo, token, host });
+
+	if (json) {
+		console.info(stringify(webhooks.map((webhook) => webhook.config)));
+		return;
+	}
+
+	if (webhooks.length === 0) {
+		console.info("No webhooks configured.");
+		return;
+	}
+
+	for (const webhook of webhooks) {
+		const status = webhook.config.active ? "enabled" : "disabled";
+		const name = webhook.config.name ? ` (${webhook.config.name})` : "";
+		console.info(`${webhook.config.url}${name}  [${status}]`);
+	}
+});

package/src/commands/webhook-remove.ts

@@ -0,0 +1,52 @@
+import { getHost, getToken } from "../auth";
+import { deleteWebhook, getWebhooks } from "../clients/wroom";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { UnknownRequestError } from "../lib/request";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic webhook remove",
+	description: `
+		Delete a webhook from a Prismic repository.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	positionals: {
+		url: { description: "Webhook URL" },
+	},
+	options: {
+		repo: { type: "string", short: "r", description: "Repository domain" },
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [webhookUrl] = positionals;
+	const { repo = await getRepositoryName() } = values;
+
+	if (!webhookUrl) {
+		throw new CommandError("Missing required argument: <url>");
+	}
+
+	const token = await getToken();
+	const host = await getHost();
+	const webhooks = await getWebhooks({ repo, token, host });
+	const webhook = webhooks.find((w) => w.config.url === webhookUrl);
+	if (!webhook) {
+		throw new CommandError(`Webhook not found: ${webhookUrl}`);
+	}
+
+	const id = webhook.config._id;
+
+	try {
+		await deleteWebhook(id, { repo, token, host });
+	} catch (error) {
+		if (error instanceof UnknownRequestError) {
+			const message = await error.text();
+			throw new CommandError(`Failed to remove webhook: ${message}`);
+		}
+		throw error;
+	}
+
+	console.info(`Webhook removed: ${webhookUrl}`);
+});