prismic 0.0.0-pr.28.59bf330

package/src/lib/auth.ts

@@ -0,0 +1,200 @@
+import { access, readFile, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { pathToFileURL } from "node:url";
+
+import { appendTrailingSlash } from "./url";
+
+const AUTH_FILE_PATH = new URL(
+	".prismic",
+	appendTrailingSlash(pathToFileURL(homedir())),
+);
+const DEFAULT_HOST = "https://prismic.io";
+const LOGIN_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes
+const PREFERRED_PORT = 5555;
+
+type AuthContents = {
+	token?: string;
+	base?: string;
+};
+
+export async function saveToken(
+	token: string,
+	options?: { base?: string },
+): Promise<void> {
+	const contents: AuthContents = { token, base: options?.base };
+	await writeFile(AUTH_FILE_PATH, JSON.stringify(contents, null, 2));
+}
+
+export async function isAuthenticated(): Promise<boolean> {
+	const token = await readToken();
+	if (!token) return false;
+
+	// Verify token is still valid by calling the profile endpoint
+	try {
+		const host = await readHost();
+		host.hostname = `user-service.${host.hostname}`;
+		const url = new URL("profile", host);
+
+		const response = await fetch(url, {
+			headers: {
+				Accept: "application/json",
+				Cookie: `SESSION=fake_session; prismic-auth=${token}`,
+			},
+		});
+
+		if (!response.ok) {
+			await removeToken();
+			return false;
+		}
+
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function readToken(): Promise<string | undefined> {
+	const auth = await readAuthFile();
+	return auth?.token;
+}
+
+export async function readHost(): Promise<URL> {
+	try {
+		const auth = await readAuthFile();
+		if (!auth?.base) return new URL(DEFAULT_HOST);
+		return new URL(auth.base);
+	} catch {
+		return new URL(DEFAULT_HOST);
+	}
+}
+
+export async function createLoginSession(options?: {
+	onReady?: (url: URL) => void;
+}): Promise<{ email: string }> {
+	const host = await readHost();
+	const corsOrigin = host.origin;
+
+	return new Promise((resolve, reject) => {
+		const server = createServer((req, res) => {
+			if (req.method === "OPTIONS") {
+				res.writeHead(204, {
+					"Access-Control-Allow-Origin": corsOrigin,
+					"Access-Control-Allow-Methods": "POST, OPTIONS",
+					"Access-Control-Allow-Headers": "Content-Type",
+				});
+				res.end();
+				return;
+			}
+
+			if (req.method === "POST") {
+				let body = "";
+
+				req.on("data", (chunk) => {
+					body += chunk.toString();
+				});
+
+				req.on("end", async () => {
+					try {
+						const { cookies, email } = JSON.parse(body);
+
+						const cookie: string | undefined = cookies.find((c: string) =>
+							c.startsWith("prismic-auth="),
+						);
+						const token = cookie?.split(";")[0]?.replace(/^prismic-auth=/, "");
+
+						if (!token) {
+							res.writeHead(400, {
+								"Access-Control-Allow-Origin": corsOrigin,
+								"Content-Type": "application/json",
+							});
+							res.end(JSON.stringify({ error: "Invalid request" }));
+							return;
+						}
+
+						await saveToken(token);
+
+						res.writeHead(200, {
+							"Access-Control-Allow-Origin": corsOrigin,
+							"Content-Type": "application/json",
+						});
+						res.end(JSON.stringify({ success: true }));
+
+						clearTimeout(timeoutId);
+						server.close();
+						resolve({ email });
+					} catch {
+						res.writeHead(400, {
+							"Access-Control-Allow-Origin": corsOrigin,
+							"Content-Type": "application/json",
+						});
+						res.end(JSON.stringify({ error: "Invalid request" }));
+					}
+				});
+
+				return;
+			}
+
+			res.writeHead(404);
+			res.end();
+		});
+
+		const timeoutId = setTimeout(() => {
+			server.close();
+			reject(new Error("Login timed out. Please try again."));
+		}, LOGIN_TIMEOUT_MS);
+
+		const onListening = (): void => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				clearTimeout(timeoutId);
+				server.close();
+				reject(new Error("Failed to start login server"));
+				return;
+			}
+
+			const url = buildLoginUrl(host, address.port);
+			options?.onReady?.(url);
+		};
+
+		server.on("error", (error: NodeJS.ErrnoException) => {
+			if (error.code === "EADDRINUSE" && server.listening === false) {
+				server.listen(0, "0.0.0.0", onListening);
+			} else {
+				clearTimeout(timeoutId);
+				reject(error);
+			}
+		});
+
+		server.listen(PREFERRED_PORT, "0.0.0.0", onListening);
+	});
+}
+
+function buildLoginUrl(host: URL, port: number): URL {
+	const url = new URL("/dashboard/cli/login", host);
+	url.searchParams.set("source", "prismic-cli");
+	url.searchParams.set("port", port.toString());
+	return url;
+}
+
+async function readAuthFile(): Promise<AuthContents | undefined> {
+	try {
+		const contents = await readFile(AUTH_FILE_PATH, "utf-8");
+		return JSON.parse(contents);
+	} catch {
+		return undefined;
+	}
+}
+
+export async function removeToken(): Promise<boolean> {
+	try {
+		await access(AUTH_FILE_PATH);
+	} catch {
+		return true;
+	}
+
+	const auth = await readAuthFile();
+	if (!auth) return false;
+	await rm(AUTH_FILE_PATH);
+	return true;
+}

package/src/lib/browser.ts

@@ -0,0 +1,11 @@
+import { exec } from "node:child_process";
+
+export function openBrowser(url: URL): void {
+	const cmd =
+		process.platform === "darwin"
+			? "open"
+			: process.platform === "win32"
+				? "start"
+				: "xdg-open";
+	exec(`${cmd} "${url.toString()}"`);
+}

package/src/lib/config.ts

@@ -0,0 +1,111 @@
+import { writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import * as v from "valibot";
+
+import { findUpward } from "./file";
+import { stringify } from "./json";
+
+const CONFIG_FILENAME = "prismic.config.json";
+
+const ConfigSchema = v.object({
+	repositoryName: v.string(),
+	apiEndpoint: v.optional(v.pipe(v.string(), v.url())),
+	localSliceMachineSimulatorURL: v.optional(v.pipe(v.string(), v.url())),
+	libraries: v.optional(v.array(v.string())),
+	adapter: v.optional(v.string()),
+	labs: v.optional(
+		v.object({
+			legacySliceUpgrader: v.optional(v.boolean()),
+		}),
+	),
+});
+type Config = v.InferOutput<typeof ConfigSchema>;
+
+export type ConfigResult = SuccessfulConfigResult | FailedConfigResult;
+export type SuccessfulConfigResult = { ok: true; config: Config };
+export type FailedConfigResult = {
+	ok: false;
+	error: InvalidPrismicConfig | MissingPrismicConfig;
+};
+export type UnknownProjectRootConfigResult = {
+	ok: false;
+	error: UnknownProjectRoot;
+};
+
+export async function createConfig(
+	config: Config,
+	cwd = pathToFileURL(process.cwd()),
+): Promise<ConfigResult | UnknownProjectRootConfigResult> {
+	const result = await findSuggestedConfigPath(cwd);
+	if (!result.ok) return result;
+	await writeFile(result.path, stringify(config));
+	return { ok: true, config };
+}
+
+export async function safeGetRepositoryFromConfig(
+	cwd = pathToFileURL(process.cwd()),
+): Promise<string | undefined> {
+	const result = await readConfig(cwd);
+	if (result.ok) return result.config.repositoryName;
+}
+
+export async function readConfig(cwd = pathToFileURL(process.cwd())): Promise<ConfigResult> {
+	const findResult = await findConfig(cwd);
+	if (!findResult.ok) return findResult;
+
+	try {
+		const contents = await readFile(findResult.path, "utf8");
+		const result = v.safeParse(ConfigSchema, JSON.parse(contents));
+		if (!result.success) {
+			return { ok: false, error: new InvalidPrismicConfig(result.issues) };
+		}
+		return { ok: true, config: result.output };
+	} catch {
+		return { ok: false, error: new InvalidPrismicConfig() };
+	}
+}
+
+export class InvalidPrismicConfig extends Error {
+	issues: v.InferIssue<typeof ConfigSchema>[];
+
+	constructor(issues: v.InferIssue<typeof ConfigSchema>[] = []) {
+		super("prismic.config.json is invalid.");
+		this.issues = issues;
+	}
+}
+
+export async function updateConfig(
+	config: Partial<Config>,
+	cwd = pathToFileURL(process.cwd()),
+): Promise<ConfigResult> {
+	const findResult = await findConfig(cwd);
+	if (!findResult.ok) return findResult;
+
+	const readResult = await readConfig(cwd);
+	if (!readResult.ok) return readResult;
+
+	const updatedConfig = { ...readResult.config, ...config };
+	await writeFile(findResult.path, stringify(updatedConfig));
+	return { ok: true, config: updatedConfig };
+}
+
+async function findConfig(cwd = pathToFileURL(process.cwd())) {
+	const path = await findUpward(CONFIG_FILENAME, { start: cwd, stop: "package.json" });
+	if (!path) return { ok: false, error: new MissingPrismicConfig() } as const;
+	return { ok: true, path } as const;
+}
+
+async function findSuggestedConfigPath(cwd = pathToFileURL(process.cwd())) {
+	const path = await findUpward("package.json", { start: cwd });
+	if (!path) return { ok: false, error: new UnknownProjectRoot() } as const;
+	return { ok: true, path: new URL(CONFIG_FILENAME, path) } as const;
+}
+
+export class MissingPrismicConfig extends Error {
+	message = "Could not find a prismic.config.json file.";
+}
+
+export class UnknownProjectRoot extends Error {
+	message = "Could not find a package.json file.";
+}

package/src/lib/custom-types-api.ts

@@ -0,0 +1,385 @@
+import type { CustomType, SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+
+import * as v from "valibot";
+
+import { readHost, readToken } from "./auth";
+
+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())),
+		}),
+	),
+});
+
+export 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 type FetchResult<T> = { ok: true; value: T } | { ok: false; error: string };
+
+export async function getCustomTypesApiUrl(): Promise<URL> {
+	const host = await readHost();
+	host.hostname = `customtypes.${host.hostname}`;
+	return host;
+}
+
+export 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}` };
+	}
+}
+
+export 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}` };
+	}
+}
+
+export async function insertCustomType(
+	repo: string,
+	model: CustomType,
+): Promise<FetchResult<void>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL("customtypes/insert", baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				repository: repo,
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify(model),
+		});
+
+		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}` };
+		}
+
+		return { ok: true, value: undefined };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+export async function updateCustomType(
+	repo: string,
+	model: CustomType,
+): Promise<FetchResult<void>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL("customtypes/update", baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				repository: repo,
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify(model),
+		});
+
+		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}` };
+		}
+
+		return { ok: true, value: undefined };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+export async function deleteCustomType(repo: string, id: string): Promise<FetchResult<void>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL(`customtypes/${encodeURIComponent(id)}`, baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			method: "DELETE",
+			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}` };
+		}
+
+		return { ok: true, value: undefined };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+export async function insertSlice(repo: string, model: SharedSlice): Promise<FetchResult<void>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL("slices/insert", baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				repository: repo,
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify(model),
+		});
+
+		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}` };
+		}
+
+		return { ok: true, value: undefined };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+export async function updateSlice(repo: string, model: SharedSlice): Promise<FetchResult<void>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL("slices/update", baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				repository: repo,
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify(model),
+		});
+
+		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}` };
+		}
+
+		return { ok: true, value: undefined };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}
+
+export async function deleteSlice(repo: string, id: string): Promise<FetchResult<void>> {
+	const token = await readToken();
+	if (!token) {
+		return { ok: false, error: "Not authenticated" };
+	}
+
+	const baseUrl = await getCustomTypesApiUrl();
+	const url = new URL(`slices/${encodeURIComponent(id)}`, baseUrl);
+
+	try {
+		const response = await fetch(url, {
+			method: "DELETE",
+			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}` };
+		}
+
+		return { ok: true, value: undefined };
+	} catch (error) {
+		return { ok: false, error: `Network error: ${error instanceof Error ? error.message : error}` };
+	}
+}