prismic 0.0.0-canary.2cfb4a8

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}` };
+	}
+}

package/src/lib/field-path.ts

@@ -0,0 +1,81 @@
+export type FieldPath =
+	| { type: "top-level"; fieldId: string }
+	| { type: "nested"; groupId: string; nestedFieldId: string };
+
+export function parseFieldPath(fieldId: string): FieldPath {
+	const parts = fieldId.split(".");
+
+	if (parts.length === 1) {
+		return { type: "top-level", fieldId };
+	}
+
+	if (parts.length === 2) {
+		return { type: "nested", groupId: parts[0], nestedFieldId: parts[1] };
+	}
+
+	// More than 2 parts means nested groups which aren't supported
+	return { type: "nested", groupId: parts[0], nestedFieldId: parts.slice(1).join(".") };
+}
+
+export type GroupFieldResult =
+	| { ok: true; group: { config: { fields: Record<string, unknown> } } }
+	| { ok: false; error: string };
+
+export function isGroupField(field: unknown): field is { type: "Group"; config: { fields: Record<string, unknown> } } {
+	return (
+		typeof field === "object" &&
+		field !== null &&
+		"type" in field &&
+		field.type === "Group" &&
+		"config" in field &&
+		typeof field.config === "object" &&
+		field.config !== null &&
+		"fields" in field.config
+	);
+}
+
+export function findGroupInTab(
+	tabFields: Record<string, unknown>,
+	groupId: string,
+	tabName: string,
+): GroupFieldResult {
+	const field = tabFields[groupId];
+
+	if (!field) {
+		return { ok: false, error: `Group "${groupId}" not found in tab "${tabName}"` };
+	}
+
+	if (!isGroupField(field)) {
+		return { ok: false, error: `Field "${groupId}" is not a group` };
+	}
+
+	return { ok: true, group: field };
+}
+
+export function findGroupInVariation(
+	primary: Record<string, unknown>,
+	groupId: string,
+	variationId: string,
+): GroupFieldResult {
+	const field = primary[groupId];
+
+	if (!field) {
+		return { ok: false, error: `Group "${groupId}" not found in variation "${variationId}"` };
+	}
+
+	if (!isGroupField(field)) {
+		return { ok: false, error: `Field "${groupId}" is not a group` };
+	}
+
+	return { ok: true, group: field };
+}
+
+export function validateNestedFieldPath(fieldPath: FieldPath): { ok: true } | { ok: false; error: string } {
+	if (fieldPath.type === "nested" && fieldPath.nestedFieldId.includes(".")) {
+		return {
+			ok: false,
+			error: `Nested groups not supported. Use: group.field`,
+		};
+	}
+	return { ok: true };
+}

package/src/lib/file.ts

@@ -0,0 +1,49 @@
+import { access } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+import { appendTrailingSlash } from "./url";
+
+export async function findUpward(
+	name: string,
+	config: { start?: URL; stop?: URL | string } = {},
+): Promise<URL | undefined> {
+	const { start = pathToFileURL(process.cwd()), stop } = config;
+
+	let dir = appendTrailingSlash(start);
+
+	while (true) {
+		const path = new URL(name, dir);
+		try {
+			await access(path);
+			return path;
+		} catch {}
+
+		if (typeof stop === "string") {
+			const stopPath = new URL(stop, dir);
+			try {
+				await access(stopPath);
+				return;
+			} catch {}
+		} else if (stop instanceof URL) {
+			if (stop.href === dir.href) {
+				return;
+			}
+		}
+
+		const parent = new URL("..", dir);
+		if (parent.href === dir.href) {
+			return undefined;
+		}
+
+		dir = parent;
+	}
+}
+
+export async function exists(path: URL): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/lib/json.ts

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

package/src/lib/packageJson.ts

@@ -0,0 +1,35 @@
+import detectIndent from "detect-indent";
+import { readFile, writeFile } from "node:fs/promises";
+
+import { findUpward } from "./file";
+
+export async function addDependencies(
+	dependencies: Record<string, string>,
+): Promise<void> {
+	const packageJsonPath = await findUpward("package.json");
+	if (!packageJsonPath) {
+		throw new Error("No package.json found");
+	}
+	const raw = await readFile(packageJsonPath, "utf8");
+	const indent = detectIndent(raw).indent || "\t";
+	const packageJson = JSON.parse(raw);
+	packageJson.dependencies = Object.fromEntries(
+		Object.entries({ ...packageJson.dependencies, ...dependencies }).sort(
+			([a], [b]) => a.localeCompare(b),
+		),
+	);
+	await writeFile(
+		packageJsonPath,
+		JSON.stringify(packageJson, null, indent) + "\n",
+	);
+}
+
+export async function getNpmPackageVersion(
+	name: string,
+	tag = "latest",
+): Promise<string> {
+	const url = new URL(`${name}/${tag}`, "https://registry.npmjs.org/");
+	const res = await fetch(url);
+	const { version } = await res.json();
+	return version;
+}

package/src/lib/profile.ts

@@ -0,0 +1,39 @@
+import * as v from "valibot";
+
+import { readToken } from "./auth";
+import { getUserServiceUrl } from "./url";
+
+const PrismicUserProfileSchema = v.object({
+	userId: v.string(),
+	shortId: v.string(),
+	intercomHash: v.string(),
+	email: v.string(),
+	firstName: v.string(),
+	lastName: v.string(),
+});
+
+export type PrismicUserProfile = v.InferOutput<typeof PrismicUserProfileSchema>;
+
+export async function getProfile(): Promise<PrismicUserProfile> {
+	const token = await readToken();
+	if (!token) {
+		throw new Error("Not authenticated. Log in before trying again.");
+	}
+
+	const baseUrl = await getUserServiceUrl();
+	const url = new URL("profile", baseUrl);
+
+	const response = await fetch(url, {
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error("Failed to retrieve profile from the Prismic user service.");
+	}
+
+	const json = await response.json();
+
+	return v.parse(PrismicUserProfileSchema, json);
+}