prismic 1.1.0 → 1.2.0

package/src/commands/webhook-set-triggers.ts

@@ -0,0 +1,93 @@
+import { getHost, getToken } from "../auth";
+import { getWebhooks, updateWebhook, 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 set-triggers",
+	description: `
+		Update which events trigger a webhook.
+
+		By default, this command reads the repository from prismic.config.json at the
+		project root.
+	`,
+	positionals: {
+		url: { description: "Webhook URL" },
+	},
+	options: {
+		trigger: {
+			type: "string",
+			multiple: true,
+			short: "t",
+			description: "Trigger events (can be repeated, at least one required)",
+		},
+		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
+		`,
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [webhookUrl] = positionals;
+	const { repo = await getRepositoryName(), trigger = [] } = values;
+
+	if (!webhookUrl) {
+		throw new CommandError("Missing required argument: <url>");
+	}
+
+	if (trigger.length === 0) {
+		throw new CommandError("Missing required option: --trigger");
+	}
+
+	// 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 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 updateWebhook(
+			id,
+			{
+				...webhook.config,
+				documentsPublished: trigger.includes("documentsPublished"),
+				documentsUnpublished: trigger.includes("documentsUnpublished"),
+				releasesCreated: trigger.includes("releasesCreated"),
+				releasesUpdated: trigger.includes("releasesUpdated"),
+				tagsCreated: trigger.includes("tagsCreated"),
+				tagsDeleted: trigger.includes("tagsDeleted"),
+			},
+			{ repo, token, host },
+		);
+	} catch (error) {
+		if (error instanceof UnknownRequestError) {
+			const message = await error.text();
+			throw new CommandError(`Failed to update webhook triggers: ${message}`);
+		}
+		throw error;
+	}
+
+	console.info(`Webhook triggers updated: ${trigger.join(", ")}`);
+});

package/src/commands/webhook-view.ts

@@ -0,0 +1,65 @@
+import { getHost, getToken } from "../auth";
+import { getWebhooks, WEBHOOK_TRIGGERS } from "../clients/wroom";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic webhook view",
+	description: `
+		View details of 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((webhook) => webhook.config.url === webhookUrl);
+	if (!webhook) {
+		throw new CommandError(`Webhook not found: ${webhookUrl}`);
+	}
+
+	const { config: webhookConfig } = webhook;
+
+	console.info(`URL:     ${webhookConfig.url}`);
+	console.info(`Name:    ${webhookConfig.name || "(none)"}`);
+	console.info(`Status:  ${webhookConfig.active ? "enabled" : "disabled"}`);
+	console.info(`Secret:  ${webhookConfig.secret ? "(set)" : "(none)"}`);
+
+	// Show triggers
+	const enabledTriggers: string[] = [];
+	for (const trigger of WEBHOOK_TRIGGERS) {
+		if (webhookConfig[trigger as keyof typeof webhookConfig]) {
+			enabledTriggers.push(trigger);
+		}
+	}
+	console.info(`Triggers: ${enabledTriggers.length > 0 ? enabledTriggers.join(", ") : "(none)"}`);
+
+	// Show headers
+	const headerKeys = Object.keys(webhookConfig.headers);
+	if (headerKeys.length > 0) {
+		console.info("Headers:");
+		for (const [key, value] of Object.entries(webhookConfig.headers)) {
+			console.info(`  ${key}: ${value}`);
+		}
+	} else {
+		console.info("Headers: (none)");
+	}
+});

package/src/commands/webhook.ts

@@ -0,0 +1,43 @@
+import { createCommandRouter } from "../lib/command";
+import webhookCreate from "./webhook-create";
+import webhookDisable from "./webhook-disable";
+import webhookEnable from "./webhook-enable";
+import webhookList from "./webhook-list";
+import webhookRemove from "./webhook-remove";
+import webhookSetTriggers from "./webhook-set-triggers";
+import webhookView from "./webhook-view";
+
+export default createCommandRouter({
+	name: "prismic webhook",
+	description: "Manage webhooks in a Prismic repository.",
+	commands: {
+		list: {
+			handler: webhookList,
+			description: "List all webhooks",
+		},
+		create: {
+			handler: webhookCreate,
+			description: "Create a new webhook",
+		},
+		view: {
+			handler: webhookView,
+			description: "View webhook details",
+		},
+		remove: {
+			handler: webhookRemove,
+			description: "Delete a webhook",
+		},
+		enable: {
+			handler: webhookEnable,
+			description: "Enable a webhook",
+		},
+		disable: {
+			handler: webhookDisable,
+			description: "Disable a webhook",
+		},
+		"set-triggers": {
+			handler: webhookSetTriggers,
+			description: "Update webhook triggers",
+		},
+	},
+});

package/src/commands/whoami.ts

@@ -1,37 +1,16 @@
-import { parseArgs } from "node:util";
-
 import { getHost, getToken } from "../auth";
 import { getProfile } from "../clients/user";
+import { createCommand, type CommandConfig } from "../lib/command";
 
-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 config = {
+	name: "prismic whoami",
+	description: "Show the currently logged in user.",
+} satisfies CommandConfig;
 
+export default createCommand(config, async () => {
 	const token = await getToken();
 	const host = await getHost();
 	const profile = await getProfile({ token, host });
 
 	console.info(profile.email);
-}
+});

package/src/config.ts

@@ -26,15 +26,6 @@ export async function createConfig(config: Config): Promise<URL> {
 	return suggestedConfigPath;
 }
 
-export async function safeGetRepositoryFromConfig(): Promise<string | undefined> {
-	try {
-		const config = await readConfig();
-		return config.repositoryName;
-	} catch {
-		return undefined;
-	}
-}
-
 export async function readConfig(): Promise<Config> {
 	const configPath = await findConfigPath();
 	try {
@@ -68,7 +59,7 @@ export async function updateConfig(updates: Partial<Config>): Promise<Config> {
 	return updatedConfig;
 }
 
-async function findConfigPath(): Promise<URL> {
+export async function findConfigPath(): Promise<URL> {
 	const configPath = await findUpward(CONFIG_FILENAME, { stop: "package.json" });
 	if (!configPath) throw new MissingPrismicConfig();
 	return configPath;
@@ -79,7 +70,7 @@ export class MissingPrismicConfig extends Error {
 	message = `Could not find a ${CONFIG_FILENAME} file.`;
 }
 
-async function findSuggestedConfigPath() {
+export async function findSuggestedConfigPath(): Promise<URL> {
 	try {
 		const packageJsonPath = await findPackageJson();
 		const suggestedConfigPath = new URL(CONFIG_FILENAME, packageJsonPath);

package/src/index.ts

@@ -3,15 +3,18 @@
 import { parseArgs } from "node:util";
 
 import packageJson from "../package.json" with { type: "json" };
+import { getAdapter, NoSupportedFrameworkError } from "./adapters";
 import { getHost, refreshToken } from "./auth";
 import { getProfile } from "./clients/user";
-import { init } from "./commands/init";
-import { login } from "./commands/login";
-import { logout } from "./commands/logout";
-import { sync } from "./commands/sync";
-import { whoami } from "./commands/whoami";
-import { InvalidPrismicConfig, MissingPrismicConfig, safeGetRepositoryFromConfig } from "./config";
-import { getFramework } from "./frameworks";
+import init from "./commands/init";
+import login from "./commands/login";
+import logout from "./commands/logout";
+import preview from "./commands/preview";
+import sync from "./commands/sync";
+import webhook from "./commands/webhook";
+import whoami from "./commands/whoami";
+import { InvalidPrismicConfig, MissingPrismicConfig } from "./config";
+import { CommandError, createCommandRouter } from "./lib/command";
 import { ForbiddenRequestError, UnauthorizedRequestError } from "./lib/request";
 import {
 	initSegment,
@@ -27,124 +30,138 @@ import {
 	sentrySetUser,
 	setupSentry,
 } from "./lib/sentry";
-
-const HELP = `
-Prismic CLI for managing repositories and configurations.
-
-USAGE
-  prismic <command> [flags]
-
-COMMANDS
-  init        Initialize a Prismic project
-  sync        Sync types and slices from Prismic
-  login       Log in to Prismic
-  logout      Log out of Prismic
-  whoami      Show the currently logged in user
-
-FLAGS
-  -v, --version  Show CLI version
-  -h, --help     Show help for command
-
-LEARN MORE
-  Use \`prismic <command> --help\` for more information about a command.
-`.trim();
-
-const UNTRACKED_COMMANDS = new Set(["login", "logout", "whoami", "sync"]);
-const SKIP_REFRESH_COMMANDS = new Set(["login", "logout"]);
-
-const {
-	positionals,
-	values: { version, help },
-} = parseArgs({
-	options: {
-		help: { type: "boolean", short: "h" },
-		version: { type: "boolean", short: "v" },
+import { safeGetRepositoryName } from "./project";
+
+const UNTRACKED_COMMANDS = ["login", "logout", "whoami", "sync"];
+const SKIP_REFRESH_COMMANDS = ["login", "logout"];
+
+const router = createCommandRouter({
+	name: "prismic",
+	description: "Prismic CLI for managing repositories and configurations.",
+	commands: {
+		init: {
+			handler: init,
+			description: "Initialize a Prismic project",
+		},
+		sync: {
+			handler: sync,
+			description: "Sync types and slices from Prismic",
+		},
+		preview: {
+			handler: preview,
+			description: "Manage preview configurations",
+		},
+		webhook: {
+			handler: webhook,
+			description: "Manage webhooks",
+		},
+		login: {
+			handler: login,
+			description: "Log in to Prismic",
+		},
+		logout: {
+			handler: logout,
+			description: "Log out of Prismic",
+		},
+		whoami: {
+			handler: whoami,
+			description: "Show the currently logged in user",
+		},
 	},
-	allowPositionals: true,
-	strict: false,
 });
 
-setupSentry();
-await initSegment();
+await main();
+
+async function main(): Promise<void> {
+	let {
+		positionals: [command],
+		values: { version, help, repo = await safeGetRepositoryName() },
+	} = parseArgs({
+		options: {
+			version: { type: "boolean", short: "v" },
+			help: { type: "boolean", short: "h" },
+			repo: { type: "string", short: "r" },
+		},
+		allowPositionals: true,
+		strict: false,
+	});
+
+	if (version) {
+		console.info(packageJson.version);
+		return;
+	}
 
-if (version) {
-	console.info(packageJson.version);
-} else {
-	const command = positionals[0];
+	if (typeof repo !== "string") repo = "";
 
-	const repository = await safeGetRepositoryFromConfig();
-	if (repository) {
-		segmentSetRepository(repository);
-		sentrySetTag("repository", repository);
-		sentrySetContext("Repository Data", { name: repository });
-	}
+	if (!help) {
+		setupSentry();
+		await initSegment();
 
-	const framework = await getFramework();
-	if (framework) {
-		sentrySetTag("framework", framework.id);
-	}
+		if (repo) {
+			segmentSetRepository(repo);
+			sentrySetTag("repository", repo);
+			sentrySetContext("Repository Data", { name: repo });
+		}
 
-	if (command && !help && !SKIP_REFRESH_COMMANDS.has(command)) {
-		// Refreesh the token and identify the user in the background.
-		refreshToken()
-			.then(async (token) => {
-				if (!token) return;
-				const host = await getHost();
-				const profile = await getProfile({ token, host });
-				segmentIdentify({ shortId: profile.shortId, intercomHash: profile.intercomHash });
-				sentrySetUser({ id: profile.shortId });
-			})
-			.catch(() => {});
-	}
+		try {
+			const adapter = await getAdapter();
+			sentrySetTag("framework", adapter.id);
+		} catch {
+			// noop - it's okay if we can't set the framework
+		}
+
+		if (command && !SKIP_REFRESH_COMMANDS.includes(command)) {
+			// Refresh the token and identify the user in the background.
+			refreshToken()
+				.then(async (token) => {
+					if (!token) return;
+					const host = await getHost();
+					const profile = await getProfile({ token, host });
+					segmentIdentify({ shortId: profile.shortId, intercomHash: profile.intercomHash });
+					sentrySetUser({ id: profile.shortId });
+				})
+				.catch(() => {});
+		}
 
-	if (command && !UNTRACKED_COMMANDS.has(command)) {
-		segmentTrackStart(command, { repository });
+		if (command && !UNTRACKED_COMMANDS.includes(command)) {
+			segmentTrackStart(command);
+		}
 	}
 
 	try {
-		switch (command) {
-			case "init":
-				await init();
-				break;
-			case "sync":
-				await sync();
-				break;
-			case "login":
-				await login();
-				break;
-			case "logout":
-				await logout();
-				break;
-			case "whoami":
-				await whoami();
-				break;
-			default: {
-				if (command) {
-					console.error(`Unknown command: ${command}`);
-					process.exitCode = 1;
-				}
-				console.info(HELP);
-			}
-		}
+		await router();
 
-		if (command && !UNTRACKED_COMMANDS.has(command)) {
-			segmentTrackEnd(command, process.exitCode !== 1);
+		if (command && !UNTRACKED_COMMANDS.includes(command)) {
+			segmentTrackEnd(command);
 		}
 	} catch (error) {
-		if (command && !UNTRACKED_COMMANDS.has(command)) {
-			segmentTrackEnd(command, false, error);
-		}
 		process.exitCode = 1;
 
+		if (!UNTRACKED_COMMANDS.includes(command)) {
+			segmentTrackEnd(command, { error });
+		}
+
+		if (error instanceof CommandError || error instanceof NoSupportedFrameworkError) {
+			console.error(error.message);
+			return;
+		}
+
 		if (error instanceof UnauthorizedRequestError || error instanceof ForbiddenRequestError) {
 			console.error("Not logged in. Run `prismic login` first.");
-		} else if (error instanceof InvalidPrismicConfig) {
+			return;
+		}
+
+		if (error instanceof InvalidPrismicConfig) {
 			console.error(`${error.message} Run \`prismic init\` to re-create a config.`);
-		} else if (error instanceof MissingPrismicConfig) {
+			return;
+		}
+
+		if (error instanceof MissingPrismicConfig) {
 			console.error(`${error.message} Run \`prismic init\` to create a config.`);
-		} else {
-			await sentryCaptureError(error);
-			throw error;
+			return;
 		}
+
+		await sentryCaptureError(error);
+		throw error;
 	}
 }