@angeloashmore/prismic-cli-poc 0.0.0-canary.1d36cd8

package/src/preview-set-simulator.ts

@@ -0,0 +1,116 @@
+import { parseArgs } from "node:util";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { stringify } from "./lib/json";
+import { ForbiddenRequestError, request } from "./lib/request";
+import { getRepoUrl } from "./lib/url";
+
+const HELP = `
+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.
+
+USAGE
+  prismic preview set-simulator <url> [flags]
+
+ARGUMENTS
+  <url>   Simulator URL (e.g. https://example.com/slice-simulator)
+
+FLAGS
+  -r, --repo string   Repository domain
+  -h, --help          Show help for command
+
+EXAMPLES
+  prismic preview set-simulator https://my-site.com
+  prismic preview set-simulator http://localhost:3000/slice-simulator
+
+LEARN MORE
+  Use \`prismic <command> <subcommand> --help\` for more information about a command.
+`.trim();
+
+export async function previewSetSimulator(): Promise<void> {
+	const {
+		values: { help, repo = await safeGetRepositoryFromConfig() },
+		positionals: [urlArg],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "preview", "set-simulator"
+		options: {
+			repo: { type: "string", short: "r" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!urlArg) {
+		console.error("Missing required argument: <url>");
+		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;
+	}
+
+	const simulatorUrl = normalizeSimulatorUrl(urlArg);
+	if (!simulatorUrl) {
+		console.error(`Invalid URL: ${urlArg}`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const response = await setSimulatorUrl(repo, simulatorUrl);
+	if (!response.ok) {
+		if (response.error instanceof ForbiddenRequestError) {
+			handleUnauthenticated();
+		} else {
+			console.error(`Failed to set simulator URL: ${stringify(response.value)}`);
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	console.info(`Simulator URL set: ${simulatorUrl}`);
+}
+
+export function normalizeSimulatorUrl(url: string): string | undefined {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.pathname.endsWith("/slice-simulator")) {
+			parsed.pathname = parsed.pathname.replace(/\/+$/, "") + "/slice-simulator";
+		}
+		return parsed.toString();
+	} catch {
+		return undefined;
+	}
+}
+
+async function setSimulatorUrl(repo: string, simulatorUrl: string) {
+	const url = new URL("/core/repository", await getRepoUrl(repo));
+	return await request(url, {
+		method: "PATCH",
+		body: { simulator_url: simulatorUrl },
+	});
+}
+
+function handleUnauthenticated() {
+	console.error("Not logged in. Run `prismic login` first.");
+	process.exitCode = 1;
+}

package/src/preview.ts

@@ -0,0 +1,75 @@
+import { parseArgs } from "node:util";
+
+import { previewAdd } from "./preview-add";
+import { previewGetSimulator } from "./preview-get-simulator";
+import { previewList } from "./preview-list";
+import { previewRemove } from "./preview-remove";
+import { previewRemoveSimulator } from "./preview-remove-simulator";
+import { previewSetName } from "./preview-set-name";
+import { previewSetSimulator } from "./preview-set-simulator";
+
+const HELP = `
+Manage preview configurations in a Prismic repository.
+
+USAGE
+  prismic preview <command> [flags]
+
+COMMANDS
+  add               Add a preview configuration
+  list              List preview configurations
+  remove            Remove a preview configuration
+  set-name          Update a preview's name
+  set-simulator     Set the slice simulator URL
+  get-simulator     Show the slice simulator URL
+  remove-simulator  Remove the slice simulator URL
+
+FLAGS
+  -h, --help   Show help for command
+
+LEARN MORE
+  Use \`prismic preview <command> --help\` for more information about a command.
+`.trim();
+
+export async function preview(): Promise<void> {
+	const {
+		positionals: [subcommand],
+	} = parseArgs({
+		args: process.argv.slice(3), // skip: node, script, "preview"
+		options: {
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+		strict: false,
+	});
+
+	switch (subcommand) {
+		case "add":
+			await previewAdd();
+			break;
+		case "list":
+			await previewList();
+			break;
+		case "remove":
+			await previewRemove();
+			break;
+		case "set-name":
+			await previewSetName();
+			break;
+		case "set-simulator":
+			await previewSetSimulator();
+			break;
+		case "get-simulator":
+			await previewGetSimulator();
+			break;
+		case "remove-simulator":
+			await previewRemoveSimulator();
+			break;
+		default: {
+			if (subcommand) {
+				console.error(`Unknown preview subcommand: ${subcommand}\n`);
+				process.exitCode = 1;
+			}
+			console.info(HELP);
+		}
+	}
+}

package/src/pull.ts

@@ -0,0 +1,247 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+
+import { buildTypes } from "./codegen-types";
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { fetchRemoteCustomTypes, fetchRemoteSlices } from "./lib/custom-types-api";
+import { findUpward } from "./lib/file";
+import { stringify } from "./lib/json";
+import { getSlicesDirectory, pascalCase } from "./lib/slice";
+
+const HELP = `
+Pull 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 pull [flags]
+
+Types are generated by default after changes. Use --no-types to skip.
+
+FLAGS
+  -r, --repo string   Repository domain
+      --dry-run       Show what would be pulled without writing files
+      --types-only    Only pull custom types
+      --slices-only   Only pull slices
+      --json          Output as JSON
+      --types string  Output file for generated types (default: "prismicio-types.d.ts")
+      --no-types      Skip type generation
+  -h, --help          Show help for command
+
+EXAMPLES
+  prismic pull
+  prismic pull --repo my-repo
+  prismic pull --dry-run
+  prismic pull --types-only
+`.trim();
+
+export async function pull(): Promise<void> {
+	const {
+		values: {
+			help,
+			repo = await safeGetRepositoryFromConfig(),
+			"dry-run": dryRun,
+			"types-only": typesOnly,
+			"slices-only": slicesOnly,
+			json,
+			types,
+			"no-types": noTypes,
+		},
+	} = parseArgs({
+		args: process.argv.slice(3), // skip: node, script, "pull"
+		options: {
+			repo: { type: "string", short: "r" },
+			"dry-run": { type: "boolean" },
+			"types-only": { type: "boolean" },
+			"slices-only": { type: "boolean" },
+			json: { type: "boolean" },
+			types: { type: "string" },
+			"no-types": { 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(`Pulling 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 pulled
+	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(
+			`\nPull complete: ${writtenTypes.length} custom types, ${writtenSlices.length} slices`,
+		);
+	}
+
+	if (!json && !noTypes) {
+		try {
+			await buildTypes({ output: types });
+			console.info(`Updated types in ${types ?? "prismicio-types.d.ts"}`);
+		} catch (error) {
+			console.warn(`Could not generate types: ${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;
+}