@angeloashmore/prismic-cli-poc 0.0.0-canary.2ff9563

package/src/slice-remove.ts

@@ -0,0 +1,81 @@
+import { rm } from "node:fs/promises";
+import { parseArgs } from "node:util";
+
+import { findSliceModel } from "./lib/slice";
+
+const HELP = `
+Remove a slice from the project.
+
+USAGE
+  prismic slice remove <slice-id> [flags]
+
+ARGUMENTS
+  slice-id     Slice identifier (required)
+
+FLAGS
+  -y           Confirm removal
+  -h, --help   Show help for command
+
+EXAMPLES
+  prismic slice remove MySlice
+  prismic slice remove MySlice -y
+`.trim();
+
+export async function sliceRemove(): Promise<void> {
+	const {
+		values: { help, y },
+		positionals: [sliceId],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "slice", "remove"
+		options: {
+			y: { type: "boolean", short: "y" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!sliceId) {
+		console.error("Missing required argument: slice-id\n");
+		console.error("Usage: prismic slice remove <slice-id>");
+		process.exitCode = 1;
+		return;
+	}
+
+	const result = await findSliceModel(sliceId);
+	if (!result.ok) {
+		console.error(result.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const { modelPath } = result;
+	const sliceDirectory = new URL(".", modelPath);
+
+	// Require -y flag to confirm deletion
+	if (!y) {
+		console.error(`Refusing to remove slice "${sliceId}" (this will delete the entire directory).`);
+		console.error("Re-run with -y to confirm.");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Delete the slice directory
+	try {
+		await rm(sliceDirectory, { recursive: true });
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Failed to remove slice: ${error.message}`);
+		} else {
+			console.error("Failed to remove slice");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	console.info(`Removed slice "${sliceId}"`);
+}

package/src/slice-rename.ts

@@ -0,0 +1,112 @@
+import { rename, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+
+import { stringify } from "./lib/json";
+import { findSliceModel, getSlicesDirectory, pascalCase } from "./lib/slice";
+
+const HELP = `
+Rename a slice (updates name field, optionally id and directory).
+
+USAGE
+  prismic slice rename <slice-id> <new-name> [flags]
+
+ARGUMENTS
+  slice-id     Current slice identifier (required)
+  new-name     New display name (required)
+
+FLAGS
+  --id string  Also change the slice ID (renames directory)
+  -h, --help   Show help for command
+
+EXAMPLES
+  prismic slice rename MySlice "My New Name"
+  prismic slice rename MySlice "My New Name" --id NewSliceId
+`.trim();
+
+export async function sliceRename(): Promise<void> {
+	const {
+		values: { help, id: newId },
+		positionals: [sliceId, newName],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "slice", "rename"
+		options: {
+			id: { type: "string" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!sliceId) {
+		console.error("Missing required argument: slice-id\n");
+		console.error("Usage: prismic slice rename <slice-id> <new-name>");
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!newName) {
+		console.error("Missing required argument: new-name\n");
+		console.error("Usage: prismic slice rename <slice-id> <new-name>");
+		process.exitCode = 1;
+		return;
+	}
+
+	const result = await findSliceModel(sliceId);
+	if (!result.ok) {
+		console.error(result.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const { model, modelPath } = result;
+
+	// Update the model
+	model.name = newName;
+	if (newId) {
+		model.id = newId;
+	}
+
+	// Write updated model
+	try {
+		await writeFile(modelPath, stringify(model));
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Failed to update slice: ${error.message}`);
+		} else {
+			console.error("Failed to update slice");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	// If changing ID, also rename the directory
+	if (newId) {
+		const slicesDirectory = await getSlicesDirectory();
+		const currentDir = new URL(".", modelPath);
+		const newDir = new URL(pascalCase(newName) + "/", slicesDirectory);
+
+		if (currentDir.href !== newDir.href) {
+			try {
+				await rename(currentDir, newDir);
+				console.info(`Renamed slice "${sliceId}" to "${newId}" (${newName})`);
+				console.info(`Moved directory to ${newDir.href}`);
+			} catch (error) {
+				if (error instanceof Error) {
+					console.error(`Failed to rename directory: ${error.message}`);
+				} else {
+					console.error("Failed to rename directory");
+				}
+				process.exitCode = 1;
+				return;
+			}
+		} else {
+			console.info(`Renamed slice "${sliceId}" to "${newId}" (${newName})`);
+		}
+	} else {
+		console.info(`Renamed slice "${sliceId}" to "${newName}"`);
+	}
+}

package/src/slice-view.ts

@@ -0,0 +1,77 @@
+import { parseArgs } from "node:util";
+
+import { findSliceModel } from "./lib/slice";
+
+const HELP = `
+View details of a specific slice.
+
+USAGE
+  prismic slice view <slice-id> [flags]
+
+ARGUMENTS
+  slice-id     Slice identifier (required)
+
+FLAGS
+  --json       Output as JSON
+  -h, --help   Show help for command
+
+EXAMPLES
+  prismic slice view MySlice
+  prismic slice view MySlice --json
+`.trim();
+
+export async function sliceView(): Promise<void> {
+	const {
+		values: { help, json },
+		positionals: [sliceId],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "slice", "view"
+		options: {
+			json: { type: "boolean" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!sliceId) {
+		console.error("Missing required argument: slice-id\n");
+		console.error("Usage: prismic slice view <slice-id>");
+		process.exitCode = 1;
+		return;
+	}
+
+	const result = await findSliceModel(sliceId);
+	if (!result.ok) {
+		console.error(result.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const { model } = result;
+
+	if (json) {
+		console.info(JSON.stringify(model, null, 2));
+		return;
+	}
+
+	console.info(`ID:           ${model.id}`);
+	console.info(`Name:         ${model.name}`);
+	if (model.description) {
+		console.info(`Description:  ${model.description}`);
+	}
+	console.info(`Variations:   ${model.variations.length}`);
+
+	console.info("\nVariations:");
+	for (const variation of model.variations) {
+		const primaryFields = Object.keys(variation.primary ?? {}).length;
+		const itemsFields = Object.keys(variation.items ?? {}).length;
+		console.info(
+			`  - ${variation.id} (${variation.name}): ${primaryFields} primary fields, ${itemsFields} items fields`,
+		);
+	}
+}

package/src/slice.ts

@@ -0,0 +1,90 @@
+import { parseArgs } from "node:util";
+
+import { sliceAddField } from "./slice-add-field";
+import { sliceAddVariation } from "./slice-add-variation";
+import { sliceCreate } from "./slice-create";
+import { sliceList } from "./slice-list";
+import { sliceListVariations } from "./slice-list-variations";
+import { sliceRemove } from "./slice-remove";
+import { sliceRemoveField } from "./slice-remove-field";
+import { sliceRemoveVariation } from "./slice-remove-variation";
+import { sliceRename } from "./slice-rename";
+import { sliceView } from "./slice-view";
+
+const HELP = `
+Manage slices in a Prismic project.
+
+USAGE
+  prismic slice <command> [flags]
+
+COMMANDS
+  create            Create a new slice
+  list              List all slices
+  view              View details of a slice
+  rename            Rename a slice
+  remove            Remove a slice
+  add-field         Add a field to a slice
+  remove-field      Remove a field from a slice
+  add-variation     Add a variation to a slice
+  remove-variation  Remove a variation from a slice
+  list-variations   List all variations of a slice
+
+FLAGS
+  -h, --help   Show help for command
+
+LEARN MORE
+  Use \`prismic slice <command> --help\` for more information about a command.
+`.trim();
+
+export async function slice(): Promise<void> {
+	const {
+		positionals: [subcommand],
+	} = parseArgs({
+		args: process.argv.slice(3), // skip: node, script, "slice"
+		options: {
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+		strict: false,
+	});
+
+	switch (subcommand) {
+		case "create":
+			await sliceCreate();
+			break;
+		case "list":
+			await sliceList();
+			break;
+		case "view":
+			await sliceView();
+			break;
+		case "rename":
+			await sliceRename();
+			break;
+		case "remove":
+			await sliceRemove();
+			break;
+		case "add-field":
+			await sliceAddField();
+			break;
+		case "remove-field":
+			await sliceRemoveField();
+			break;
+		case "add-variation":
+			await sliceAddVariation();
+			break;
+		case "remove-variation":
+			await sliceRemoveVariation();
+			break;
+		case "list-variations":
+			await sliceListVariations();
+			break;
+		default: {
+			if (subcommand) {
+				console.error(`Unknown slice subcommand: ${subcommand}\n`);
+				process.exitCode = 1;
+			}
+			console.info(HELP);
+		}
+	}
+}

package/src/sync.ts

@@ -0,0 +1,309 @@
+import type { CustomType, SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+import * as v from "valibot";
+
+import { isAuthenticated, readHost, readToken } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { findUpward } from "./lib/file";
+import { stringify } from "./lib/json";
+import { getSlicesDirectory, pascalCase, SharedSliceSchema } from "./lib/slice";
+
+const HELP = `
+Sync custom types and slices from Prismic to local files.
+
+By default, this command reads the repository from prismic.config.json at the
+project root.
+
+USAGE
+  prismic sync [flags]
+
+FLAGS
+  -r, --repo string   Repository domain
+      --dry-run       Show what would be synced without writing files
+      --types-only    Only sync custom types
+      --slices-only   Only sync slices
+      --json          Output as JSON
+  -h, --help          Show help for command
+
+EXAMPLES
+  prismic sync
+  prismic sync --repo my-repo
+  prismic sync --dry-run
+  prismic sync --types-only
+`.trim();
+
+const CustomTypeSchema = v.object({
+	id: v.string(),
+	label: v.optional(v.string()),
+	repeatable: v.boolean(),
+	status: v.boolean(),
+	format: v.optional(v.string()),
+	json: v.record(v.string(), v.unknown()),
+});
+
+export async function sync(): Promise<void> {
+	const {
+		values: { help, repo = await safeGetRepositoryFromConfig(), "dry-run": dryRun, "types-only": typesOnly, "slices-only": slicesOnly, json },
+	} = parseArgs({
+		args: process.argv.slice(3), // skip: node, script, "sync"
+		options: {
+			repo: { type: "string", short: "r" },
+			"dry-run": { type: "boolean" },
+			"types-only": { type: "boolean" },
+			"slices-only": { type: "boolean" },
+			json: { type: "boolean" },
+			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;
+	}
+
+	// Check authentication
+	if (!(await isAuthenticated())) {
+		console.error("Not logged in. Run `prismic login` first.");
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!json) {
+		console.info(`Syncing from repository: ${repo}\n`);
+	}
+
+	// Fetch remote data in parallel
+	const shouldFetchTypes = !slicesOnly;
+	const shouldFetchSlices = !typesOnly;
+
+	const [customTypesResult, slicesResult] = await Promise.all([
+		shouldFetchTypes ? fetchRemoteCustomTypes(repo) : Promise.resolve({ ok: true, value: [] } as const),
+		shouldFetchSlices ? fetchRemoteSlices(repo) : Promise.resolve({ ok: true, value: [] } as const),
+	]);
+
+	if (!customTypesResult.ok) {
+		console.error(`Failed to fetch custom types: ${customTypesResult.error}`);
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!slicesResult.ok) {
+		console.error(`Failed to fetch slices: ${slicesResult.error}`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const customTypes = customTypesResult.value;
+	const slices = slicesResult.value;
+
+	if (!json) {
+		if (shouldFetchTypes) {
+			console.info(`Fetching custom types... ${customTypes.length} types`);
+		}
+		if (shouldFetchSlices) {
+			console.info(`Fetching slices... ${slices.length} slices`);
+		}
+	}
+
+	// Dry run - just show what would be synced
+	if (dryRun) {
+		if (json) {
+			console.info(stringify({ customTypes, slices }));
+		} else {
+			console.info("");
+			if (shouldFetchTypes && customTypes.length > 0) {
+				console.info("Would write custom types:");
+				for (const ct of customTypes) {
+					console.info(`  customtypes/${ct.id}/index.json`);
+				}
+			}
+			if (shouldFetchSlices && slices.length > 0) {
+				const slicesDir = await getSlicesDirectory();
+				const relativeSlicesDir = getRelativePath(slicesDir);
+				console.info("Would write slices:");
+				for (const slice of slices) {
+					console.info(`  ${relativeSlicesDir}${pascalCase(slice.name)}/model.json`);
+				}
+			}
+			console.info(`\nDry run complete: ${customTypes.length} custom types, ${slices.length} slices`);
+		}
+		return;
+	}
+
+	// Find project root
+	const projectRoot = await findUpward("package.json");
+	if (!projectRoot) {
+		console.error("Could not find project root (no package.json found)");
+		process.exitCode = 1;
+		return;
+	}
+	const projectDir = new URL(".", projectRoot);
+
+	const writtenTypes: string[] = [];
+	const writtenSlices: string[] = [];
+
+	// Write custom types
+	if (shouldFetchTypes && customTypes.length > 0) {
+		if (!json) {
+			console.info("\nWriting custom types:");
+		}
+		const customTypesDir = new URL("customtypes/", projectDir);
+
+		for (const ct of customTypes) {
+			const typeDir = new URL(`${ct.id}/`, customTypesDir);
+			const modelPath = new URL("index.json", typeDir);
+
+			try {
+				await mkdir(typeDir, { recursive: true });
+				await writeFile(modelPath, stringify(ct));
+				const relativePath = `customtypes/${ct.id}/index.json`;
+				writtenTypes.push(relativePath);
+				if (!json) {
+					console.info(`  ${relativePath}`);
+				}
+			} catch (error) {
+				console.error(`Failed to write custom type ${ct.id}: ${error instanceof Error ? error.message : error}`);
+				process.exitCode = 1;
+				return;
+			}
+		}
+	}
+
+	// Write slices
+	if (shouldFetchSlices && slices.length > 0) {
+		if (!json) {
+			console.info("\nWriting slices:");
+		}
+		const slicesDir = await getSlicesDirectory();
+
+		for (const slice of slices) {
+			const sliceDir = new URL(`${pascalCase(slice.name)}/`, slicesDir);
+			const modelPath = new URL("model.json", sliceDir);
+
+			try {
+				await mkdir(sliceDir, { recursive: true });
+				await writeFile(modelPath, stringify(slice));
+				const relativePath = `${getRelativePath(slicesDir)}${pascalCase(slice.name)}/model.json`;
+				writtenSlices.push(relativePath);
+				if (!json) {
+					console.info(`  ${relativePath}`);
+				}
+			} catch (error) {
+				console.error(`Failed to write slice ${slice.name}: ${error instanceof Error ? error.message : error}`);
+				process.exitCode = 1;
+				return;
+			}
+		}
+	}
+
+	// Output summary
+	if (json) {
+		console.info(stringify({ writtenTypes, writtenSlices }));
+	} else {
+		console.info(`\nSync complete: ${writtenTypes.length} custom types, ${writtenSlices.length} slices`);
+	}
+}
+
+async function getCustomTypesApiUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `customtypes.${host.hostname}`;
+	return host;
+}
+
+type FetchResult<T> = { ok: true; value: T } | { ok: false; error: string };
+
+async function fetchRemoteCustomTypes(repo: string): Promise<FetchResult<CustomType[]>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL("customtypes", baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				repository: repo,
+			},
+		});
+
+		if (!response.ok) {
+			if (response.status === 401) {
+				return { ok: false, error: "Unauthorized. Your session may have expired. Run `prismic login` again." };
+			}
+			if (response.status === 403) {
+				return { ok: false, error: `Access denied. You may not have access to repository "${repo}".` };
+			}
+			return { ok: false, error: `API error: ${response.status} ${response.statusText}` };
+		}
+
+		const data = await response.json();
+		const result = v.safeParse(v.array(CustomTypeSchema), data);
+		if (!result.success) {
+			return { ok: false, error: "Invalid response from Custom Types API" };
+		}
+
+		return { ok: true, value: result.output as CustomType[] };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+async function fetchRemoteSlices(repo: string): Promise<FetchResult<SharedSlice[]>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL("slices", baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				repository: repo,
+			},
+		});
+
+		if (!response.ok) {
+			if (response.status === 401) {
+				return { ok: false, error: "Unauthorized. Your session may have expired. Run `prismic login` again." };
+			}
+			if (response.status === 403) {
+				return { ok: false, error: `Access denied. You may not have access to repository "${repo}".` };
+			}
+			return { ok: false, error: `API error: ${response.status} ${response.statusText}` };
+		}
+
+		const data = await response.json();
+		const result = v.safeParse(v.array(SharedSliceSchema), data);
+		if (!result.success) {
+			return { ok: false, error: "Invalid response from Custom Types API" };
+		}
+
+		return { ok: true, value: result.output as SharedSlice[] };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+function getRelativePath(url: URL): string {
+	const cwd = process.cwd();
+	const path = url.pathname;
+	if (path.startsWith(cwd)) {
+		return path.slice(cwd.length + 1);
+	}
+	return path;
+}