@angeloashmore/prismic-cli-poc 0.0.0-canary.1143872

package/src/lib/framework.ts

@@ -0,0 +1,143 @@
+import { readFile } from "node:fs/promises";
+import * as v from "valibot";
+
+import { exists, findUpward } from "./file";
+
+export type Framework = "next" | "nuxt" | "sveltekit";
+
+export type FrameworkInfo = {
+	framework: Framework | undefined;
+	hasSrcDir: boolean;
+	projectRoot: URL;
+};
+
+const PackageJsonSchema = v.object({
+	dependencies: v.optional(v.record(v.string(), v.string())),
+	devDependencies: v.optional(v.record(v.string(), v.string())),
+});
+
+export async function detectFrameworkInfo(): Promise<FrameworkInfo | undefined> {
+	const packageJsonPath = await findUpward("package.json");
+	if (!packageJsonPath) return undefined;
+
+	const projectRoot = new URL(".", packageJsonPath);
+
+	let framework: Framework | undefined;
+	try {
+		const contents = await readFile(packageJsonPath, "utf8");
+		const { dependencies = {}, devDependencies = {} } = v.parse(
+			PackageJsonSchema,
+			JSON.parse(contents),
+		);
+		const allDeps = { ...dependencies, ...devDependencies };
+		if ("next" in allDeps) framework = "next";
+		else if ("nuxt" in allDeps) framework = "nuxt";
+		else if ("@sveltejs/kit" in allDeps) framework = "sveltekit";
+	} catch {
+		// Continue with undefined framework
+	}
+
+	let hasSrcDir = false;
+	if (framework === "next" || framework === "sveltekit") {
+		hasSrcDir = await exists(new URL("src/", projectRoot));
+	} else if (framework === "nuxt") {
+		hasSrcDir = await exists(new URL("app/", projectRoot));
+	}
+
+	return { framework, hasSrcDir, projectRoot };
+}
+
+export function getRequiredDependencies(framework: Framework | undefined): string[] {
+	switch (framework) {
+		case "next":
+			return ["@prismicio/client", "@prismicio/react", "@prismicio/next"];
+		case "nuxt":
+			return ["@nuxtjs/prismic"];
+		case "sveltekit":
+			return ["@prismicio/client", "@prismicio/svelte"];
+		default:
+			return ["@prismicio/client"];
+	}
+}
+
+export function getClientFilePath(info: FrameworkInfo): string | null {
+	switch (info.framework) {
+		case "next":
+			return info.hasSrcDir ? "src/prismicio.ts" : "prismicio.ts";
+		case "nuxt":
+			return null; // Nuxt uses nuxt.config.ts instead
+		case "sveltekit":
+			return "src/lib/prismicio.ts";
+		default:
+			return "prismicio.ts";
+	}
+}
+
+export function getSlicesDirectory(info: FrameworkInfo): string {
+	switch (info.framework) {
+		case "next":
+			return info.hasSrcDir ? "src/slices/" : "slices/";
+		case "nuxt":
+			return info.hasSrcDir ? "app/slices/" : "slices/";
+		case "sveltekit":
+			return "src/lib/slices/";
+		default:
+			return "slices/";
+	}
+}
+
+export function getSliceComponentExtensions(framework: Framework | undefined): string[] {
+	switch (framework) {
+		case "next":
+			return [".tsx", ".ts", ".jsx", ".js"];
+		case "nuxt":
+			return [".vue"];
+		case "sveltekit":
+			return [".svelte"];
+		default:
+			return [".tsx", ".ts", ".jsx", ".js"];
+	}
+}
+
+export function getRoutePath(
+	info: FrameworkInfo,
+	route: string,
+): { path: string; extensions: string[] } | null {
+	switch (info.framework) {
+		case "next": {
+			const base = info.hasSrcDir ? "src/app" : "app";
+			if (route === "/slice-simulator") {
+				return { path: `${base}/slice-simulator/page`, extensions: [".tsx", ".ts", ".jsx", ".js"] };
+			}
+			if (route === "/api/preview") {
+				return { path: `${base}/api/preview/route`, extensions: [".ts", ".js"] };
+			}
+			if (route === "/api/exit-preview") {
+				return { path: `${base}/api/exit-preview/route`, extensions: [".ts", ".js"] };
+			}
+			if (route === "/api/revalidate") {
+				return { path: `${base}/api/revalidate/route`, extensions: [".ts", ".js"] };
+			}
+			return null;
+		}
+		case "nuxt": {
+			if (route === "/slice-simulator") {
+				return { path: "pages/slice-simulator", extensions: [".vue"] };
+			}
+			// Preview endpoints are built-in for Nuxt
+			return null;
+		}
+		case "sveltekit": {
+			if (route === "/slice-simulator") {
+				return { path: "src/routes/slice-simulator/+page", extensions: [".svelte"] };
+			}
+			if (route === "/api/preview") {
+				return { path: "src/routes/api/preview/+server", extensions: [".ts", ".js"] };
+			}
+			// exit-preview not required for SvelteKit
+			return null;
+		}
+		default:
+			return null;
+	}
+}

package/src/lib/json.ts

@@ -0,0 +1,3 @@
+export function stringify(input: unknown): string {
+	return JSON.stringify(input, null, 2);
+}

package/src/lib/request.ts

@@ -0,0 +1,116 @@
+import * as v from "valibot";
+
+import { readToken } from "./auth";
+
+type CustomRequestInit = Omit<RequestInit, "body"> & {
+	body?: RequestInit["body"] | Record<PropertyKey, unknown>;
+};
+
+export type RequestResponse<T> = SuccessfulRequestResponse<T> | FailedRequestResponse;
+export type ParsedRequestResponse<T> =
+	| RequestResponse<T>
+	| { ok: false; value: unknown; error: v.ValiError<v.GenericSchema<T>> };
+export type SuccessfulRequestResponse<T> = { ok: true; value: T };
+export type FailedRequestResponse = {
+	ok: false;
+	value: unknown;
+	error: RequestError | ForbiddenRequestError | UnauthorizedRequestError;
+};
+export type FailedParsedRequestResponse<T> =
+	| FailedRequestResponse
+	| { ok: false; value: unknown; error: v.ValiError<v.GenericSchema<T>> };
+
+export async function request<T>(
+	input: RequestInfo | URL,
+	init?: CustomRequestInit,
+): Promise<RequestResponse<T>>;
+export async function request<T>(
+	input: RequestInfo | URL,
+	init: CustomRequestInit & { schema: v.GenericSchema<T> },
+): Promise<ParsedRequestResponse<T>>;
+export async function request<T>(
+	input: RequestInfo | URL,
+	init: CustomRequestInit & { schema?: v.GenericSchema<T> } = {},
+): Promise<ParsedRequestResponse<T>> {
+	const { credentials = "include" } = init;
+
+	const headers = new Headers(init.headers);
+	headers.set("Accept", "application/json");
+	if (credentials === "include") {
+		const token = await readToken();
+		if (token) headers.set("Cookie", `SESSION=fake_session; prismic-auth=${token}`);
+	}
+	if (!headers.has("Content-Type") && init.body) {
+		headers.set("Content-Type", "application/json");
+	}
+	if (init.body instanceof FormData) {
+		headers.delete("Content-Type");
+	}
+
+	const body =
+		headers.get("Content-Type") === "application/json"
+			? JSON.stringify(init.body)
+			: (init.body as RequestInit["body"]);
+
+	const response = await fetch(input, { ...init, body, headers });
+
+	const value = await response
+		.clone()
+		.json()
+		.catch(() => response.clone().text());
+
+	if (response.ok) {
+		if (!init?.schema) return { ok: true, value };
+
+		try {
+			const parsed = v.parse(init.schema, value);
+			return { ok: true, value: parsed };
+		} catch (error) {
+			if (v.isValiError<v.GenericSchema<T>>(error)) {
+				return { ok: false, value, error };
+			}
+			throw error;
+		}
+	} else {
+		if (response.status === 401) {
+			const error = new UnauthorizedRequestError(response);
+			return { ok: false, value, error };
+		} else if (response.status === 403) {
+			const error = new ForbiddenRequestError(response);
+			return { ok: false, value, error };
+		} else {
+			const error = new RequestError(response);
+			return { ok: false, value, error };
+		}
+	}
+}
+
+export class RequestError extends Error {
+	name = "RequestError" as const;
+	response: Response;
+
+	constructor(response: Response) {
+		super(`fetch failed: ${response.url}`);
+		this.response = response;
+	}
+
+	async text(): Promise<string> {
+		return this.response.clone().text();
+	}
+
+	async json(): Promise<unknown> {
+		return this.response.clone().json();
+	}
+
+	get status(): number {
+		return this.response.status;
+	}
+
+	get statusText(): string {
+		return this.response.statusText;
+	}
+}
+
+export class ForbiddenRequestError extends RequestError {}
+
+export class UnauthorizedRequestError extends RequestError {}

package/src/lib/slice.ts

@@ -0,0 +1,115 @@
+import type { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+
+import { readdir, readFile } from "node:fs/promises";
+import * as v from "valibot";
+
+import { exists, findUpward } from "./file";
+
+export const SharedSliceSchema = v.object({
+	id: v.string(),
+	type: v.literal("SharedSlice"),
+	name: v.string(),
+	description: v.optional(v.string()),
+	variations: v.array(
+		v.object({
+			id: v.string(),
+			name: v.string(),
+			description: v.optional(v.string()),
+			docURL: v.optional(v.string()),
+			version: v.optional(v.string()),
+			imageUrl: v.optional(v.string()),
+			primary: v.optional(v.record(v.string(), v.unknown())),
+			items: v.optional(v.record(v.string(), v.unknown())),
+		}),
+	),
+});
+
+type SliceModelResult =
+	| { ok: true; model: SharedSlice; modelPath: URL }
+	| { ok: false; error: string };
+
+export async function findSliceModel(sliceId: string): Promise<SliceModelResult> {
+	const projectRoot = await findUpward("package.json");
+	if (!projectRoot) {
+		return { ok: false, error: "Could not find project root (no package.json found)" };
+	}
+
+	const slicesDirectory = await getSlicesDirectory();
+
+	// List all directories in slices folder
+	let entries: string[];
+	try {
+		entries = (await readdir(slicesDirectory, { withFileTypes: false })) as unknown as string[];
+	} catch {
+		return { ok: false, error: `No slices directory found at ${slicesDirectory.href}` };
+	}
+
+	// Search for a slice with matching ID
+	for (const entry of entries) {
+		const modelPath = new URL(`${entry}/model.json`, slicesDirectory);
+		try {
+			const contents = await readFile(modelPath, "utf8");
+			const parsed = JSON.parse(contents);
+			if (parsed.id === sliceId) {
+				const result = v.safeParse(SharedSliceSchema, parsed);
+				if (!result.success) {
+					return { ok: false, error: `Invalid slice model at ${modelPath.href}` };
+				}
+				return { ok: true, model: result.output as SharedSlice, modelPath };
+			}
+		} catch {
+			// Skip directories without valid model.json
+		}
+	}
+
+	return {
+		ok: false,
+		error: `Slice not found: ${sliceId}\n\nCreate it first with: prismic slice create ${sliceId}`,
+	};
+}
+
+export async function getSlicesDirectory(): Promise<URL> {
+	const framework = await detectFramework();
+	const projectRoot = await findUpward("package.json");
+	if (!projectRoot) {
+		throw new Error("Could not find project root (no package.json found)");
+	}
+	const projectDir = new URL(".", projectRoot);
+
+	switch (framework) {
+		case "next": {
+			const hasSrcDir = await exists(new URL("src", projectDir));
+			if (hasSrcDir) return new URL("src/slices/", projectDir);
+		}
+		case "nuxt": {
+			const hasAppDir = await exists(new URL("app", projectDir));
+			if (hasAppDir) return new URL("app/slices/", projectDir);
+		}
+		case "sveltekit": {
+			return new URL("src/slices/", projectDir);
+		}
+	}
+	return new URL("slices/", projectDir);
+}
+
+const PackageJsonSchema = v.object({
+	dependencies: v.optional(v.record(v.string(), v.string())),
+});
+
+type Framework = "next" | "nuxt" | "sveltekit";
+
+async function detectFramework(): Promise<Framework | undefined> {
+	const packageJsonPath = await findUpward("package.json");
+	if (!packageJsonPath) return;
+	try {
+		const contents = await readFile(packageJsonPath, "utf8");
+		const { dependencies = {} } = v.parse(PackageJsonSchema, JSON.parse(contents));
+		if ("next" in dependencies) return "next";
+		if ("nuxt" in dependencies) return "nuxt";
+		if ("@sveltejs/kit" in dependencies) return "sveltekit";
+	} catch {}
+}
+
+export function pascalCase(input: string): string {
+	return input.toLowerCase().replace(/(^|[-_\s]+)(.)?/g, (_, __, c) => c?.toUpperCase() ?? "");
+}

package/src/lib/string.ts

@@ -0,0 +1,6 @@
+export function humanReadable(id: string): string {
+	return id
+		.replace(/([a-z])([A-Z])/g, "$1 $2")
+		.replace(/[_-]+/g, " ")
+		.replace(/\b\w/g, (c) => c.toUpperCase());
+}

package/src/lib/url.ts

@@ -0,0 +1,25 @@
+import { readHost } from "./auth";
+
+export async function getRepoUrl(repo: string): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `${repo}.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export async function getInternalApiUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `api.internal.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export async function getUserServiceUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `user-service.${host.hostname}`;
+	return appendTrailingSlash(host);
+}
+
+export function appendTrailingSlash(url: string | URL): URL {
+	const newURL = new URL(url);
+	if (!newURL.pathname.endsWith("/")) newURL.pathname += "/";
+	return newURL;
+}

package/src/locale-add.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 = `
+Add a new locale to a Prismic repository.
+
+By default, this command reads the repository from prismic.config.json at the
+project root.
+
+USAGE
+  prismic locale add <code> [flags]
+
+ARGUMENTS
+  <code>   Locale code (e.g. fr-fr, es-es)
+
+FLAGS
+  -n, --name string   Custom display name (creates custom locale)
+  -r, --repo string   Repository domain
+  -h, --help          Show help for command
+
+LEARN MORE
+  Use \`prismic <command> <subcommand> --help\` for more information about a command.
+`.trim();
+
+export async function localeAdd(): Promise<void> {
+	const {
+		values: { help, name, repo = await safeGetRepositoryFromConfig() },
+		positionals: [code],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "locale", "add"
+		options: {
+			name: { type: "string", short: "n" },
+			repo: { type: "string", short: "r" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!code) {
+		console.error("Missing required argument: <code>");
+		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 response = name
+		? await addCustomLocale(repo, code, name)
+		: await addStandardLocale(repo, code);
+	if (!response.ok) {
+		if (
+			typeof response.value === "string" &&
+			response.value.includes("already existing languages")
+		) {
+			// Treat as success
+			return;
+		}
+
+		if (response.error instanceof ForbiddenRequestError) {
+			handleUnauthenticated();
+		} else {
+			console.error(`Failed to add locale: ${stringify(response.value)}`);
+			process.exitCode = 1;
+		}
+
+		return;
+	}
+
+	console.info(`Locale added: ${code}`);
+}
+
+async function addStandardLocale(repo: string, code: string) {
+	const url = new URL("/app/settings/multilanguages", await getRepoUrl(repo));
+	return await request(url, {
+		method: "POST",
+		body: { languages: [code] },
+	});
+}
+
+async function addCustomLocale(repo: string, code: string, name: string) {
+	const [langPart, regionPart] = code.split("-");
+	const url = new URL("/app/settings/multilanguages/custom", await getRepoUrl(repo));
+	return await request(url, {
+		method: "POST",
+		body: {
+			lang: { label: name, id: langPart || code },
+			region: { label: name, id: regionPart || langPart || code },
+		},
+	});
+}
+
+function handleUnauthenticated() {
+	console.error("Not logged in. Run `prismic login` first.");
+	process.exitCode = 1;
+}

package/src/locale-list.ts

@@ -0,0 +1,107 @@
+import { parseArgs } from "node:util";
+import * as v from "valibot";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { stringify } from "./lib/json";
+import { ForbiddenRequestError, type ParsedRequestResponse, request } from "./lib/request";
+import { getInternalApiUrl } from "./lib/url";
+
+const HELP = `
+List all locales in a Prismic repository.
+
+By default, this command reads the repository from prismic.config.json at the
+project root.
+
+USAGE
+  prismic locale list [flags]
+
+FLAGS
+      --json          Output as JSON
+  -r, --repo string   Repository domain
+  -h, --help          Show help for command
+
+LEARN MORE
+  Use \`prismic <command> <subcommand> --help\` for more information about a command.
+`.trim();
+
+export async function localeList(): Promise<void> {
+	const {
+		values: { help, repo = await safeGetRepositoryFromConfig(), json },
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "locale", "list"
+		options: {
+			json: { type: "boolean" },
+			repo: { type: "string", short: "r" },
+			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;
+	}
+
+	const authenticated = await isAuthenticated();
+	if (!authenticated) {
+		handleUnauthenticated();
+		return;
+	}
+
+	const response = await getLocales(repo);
+	if (!response.ok) {
+		if (response.error instanceof ForbiddenRequestError) {
+			handleUnauthenticated();
+		} else if (v.isValiError(response.error)) {
+			console.error(
+				`Failed to list locales: Invalid response: ${stringify(response.error.issues)}`,
+			);
+			process.exitCode = 1;
+		} else {
+			console.error(`Failed to list locales: ${stringify(response.value)}`);
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	const locales = response.value.results;
+	if (json) {
+		console.info(stringify(locales));
+	} else {
+		for (const locale of locales) {
+			const defaultLabel = locale.isMaster ? " (default)" : "";
+			console.info(`${locale.id}  ${locale.label}${defaultLabel}`);
+		}
+	}
+}
+
+const LocaleSchema = v.object({
+	id: v.string(),
+	label: v.string(),
+	customName: v.nullable(v.string()),
+	isMaster: v.boolean(),
+});
+export type Locale = v.InferOutput<typeof LocaleSchema>;
+
+const GetLocalesResponseSchema = v.object({
+	results: v.array(LocaleSchema),
+});
+type GetLocalesResponse = v.InferOutput<typeof GetLocalesResponseSchema>;
+
+export async function getLocales(repo: string): Promise<ParsedRequestResponse<GetLocalesResponse>> {
+	const url = new URL("/locale/repository/locales", await getInternalApiUrl());
+	url.searchParams.set("repository", repo);
+	return await request(url, { schema: GetLocalesResponseSchema });
+}
+
+function handleUnauthenticated() {
+	console.error("Not logged in. Run `prismic login` first.");
+	process.exitCode = 1;
+}