prismic 0.0.0-canary.169f5fa

package/src/frameworks/sveltekit.ts

@@ -0,0 +1,241 @@
+import type { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+
+import { loadFile } from "magicast";
+import { mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+
+import type { Framework } from ".";
+
+import { FrameworkAdapter } from ".";
+import { exists } from "../lib/file";
+import { getNpmPackageVersion } from "../lib/packageJson";
+import { dedent } from "../lib/string";
+import {
+	previewAPIRouteTemplate,
+	prismicIOFileTemplate,
+	rootLayoutTemplate,
+	sliceSimulatorPageTemplate,
+	sliceTemplate,
+} from "./sveltekit.templates";
+
+export class SvelteKitFramework extends FrameworkAdapter {
+	readonly id: Framework = "sveltekit";
+
+	async getDependencies(): Promise<Record<string, string>> {
+		return {
+			"@prismicio/client": `^${await getNpmPackageVersion("@prismicio/client")}`,
+			"@prismicio/svelte": `^${await getNpmPackageVersion("@prismicio/svelte")}`,
+		};
+	}
+
+	async initProject(): Promise<void> {
+		await super.initProject();
+
+		await this.#createPrismicIOFile();
+		await this.#createSliceSimulatorPage();
+		await this.#createPreviewRouteMatcher();
+		await this.#createPreviewAPIRoute();
+		await this.#createPreviewRouteDirectory();
+		await this.#createRootLayoutServerFile();
+		await this.#createRootLayoutFile();
+		await this.#modifyViteConfig();
+	}
+
+	async createSliceComponent(
+		model: SharedSlice,
+		sliceDirectory: URL,
+	): Promise<{ componentPath: URL }> {
+		const componentPath = new URL("index.svelte", sliceDirectory);
+		const contents = sliceTemplate({
+			name: model.name,
+			typescript: await this.checkIsTypeScriptProject(),
+			version: await this.#getSvelteMajor(),
+		});
+		await writeFile(componentPath, contents);
+		return { componentPath };
+	}
+
+	getSliceImportPath(relativeDirectory: string): string {
+		return `./${relativeDirectory}/index.svelte`;
+	}
+
+	async getDefaultSliceLibraryPath(projectRoot: URL): Promise<URL> {
+		return new URL("src/lib/slices/", projectRoot);
+	}
+
+	async getClientFilePath(): Promise<string | null> {
+		return "src/lib/prismicio.ts";
+	}
+
+	async getSlicesDirectoryPath(): Promise<string> {
+		return "src/lib/slices/";
+	}
+
+	getSliceComponentExtensions(): string[] {
+		return [".svelte"];
+	}
+
+	async getRoutePath(route: string): Promise<{ path: string; extensions: string[] } | null> {
+		switch (route) {
+			case "/slice-simulator":
+				return { path: "src/routes/slice-simulator/+page", extensions: [".svelte"] };
+			case "/api/preview":
+				return { path: "src/routes/api/preview/+server", extensions: [".ts", ".js"] };
+			default:
+				return null;
+		}
+	}
+
+	async #createPrismicIOFile(): Promise<void> {
+		const extension = await this.getJsFileExtension();
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL(`src/lib/prismicio.${extension}`, projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const typescript = await this.checkIsTypeScriptProject();
+		const contents = prismicIOFileTemplate({ typescript });
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #createSliceSimulatorPage(): Promise<void> {
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL("src/routes/slice-simulator/+page.svelte", projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const contents = sliceSimulatorPageTemplate({
+			version: await this.#getSvelteMajor(),
+		});
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #createPreviewRouteMatcher(): Promise<void> {
+		const extension = await this.getJsFileExtension();
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL(`src/params/preview.${extension}`, projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const contents = dedent`
+			export function match(param) {
+				return param === 'preview';
+			}
+		`;
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #createPreviewAPIRoute(): Promise<void> {
+		const extension = await this.getJsFileExtension();
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL(`src/routes/api/preview/+server.${extension}`, projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const typescript = await this.checkIsTypeScriptProject();
+		const contents = previewAPIRouteTemplate({ typescript });
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #createPreviewRouteDirectory(): Promise<void> {
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL("src/routes/[[preview=preview]]/README.md", projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const contents = dedent`
+			This directory adds support for optional \`/preview\` routes. Do not remove this directory.
+
+			All routes within this directory will be served using the following URLs:
+
+			- \`/example-route\` (prerendered)
+			- \`/preview/example-route\` (server-rendered)
+
+			See <https://prismic.io/docs/svelte-preview> for more information.
+		`;
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #createRootLayoutServerFile(): Promise<void> {
+		const extension = await this.getJsFileExtension();
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL(`src/routes/+layout.server.${extension}`, projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const contents = dedent`
+			export const prerender = "auto";
+		`;
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #createRootLayoutFile(): Promise<void> {
+		const projectRoot = await this.getProjectRoot();
+		const filePath = new URL("src/routes/+layout.svelte", projectRoot);
+
+		if (await exists(filePath)) {
+			return;
+		}
+
+		const contents = rootLayoutTemplate({
+			version: await this.#getSvelteMajor(),
+		});
+		await mkdir(new URL(".", filePath), { recursive: true });
+		await writeFile(filePath, contents);
+	}
+
+	async #modifyViteConfig(): Promise<void> {
+		const projectRoot = await this.getProjectRoot();
+		let configUrl = new URL("vite.config.js", projectRoot);
+		if (!(await exists(configUrl))) {
+			configUrl = new URL("vite.config.ts", projectRoot);
+		}
+		if (!(await exists(configUrl))) {
+			return;
+		}
+
+		const filepath = configUrl.pathname;
+		const mod = await loadFile(filepath);
+		if (mod.exports.default.$type !== "function-call") {
+			return;
+		}
+
+		const config = mod.exports.default.$args[0];
+		config.server ??= {};
+		config.server.fs ??= {};
+		config.server.fs.allow ??= [];
+		if (!config.server.fs.allow.includes("./prismic.config.json")) {
+			config.server.fs.allow.push("./prismic.config.json");
+		}
+
+		const contents = mod.generate().code.replace(/\n\s*\n(?=\s*server:)/, "\n");
+		await writeFile(configUrl, contents);
+	}
+
+	async #getSvelteMajor(): Promise<number> {
+		const projectRoot = await this.getProjectRoot();
+		const require = createRequire(new URL("package.json", projectRoot));
+		const { version } = require("svelte/package.json");
+		const major = Number.parseInt(version.split(".")[0]);
+		if (Number.isNaN(major)) return Infinity;
+		return major;
+	}
+}

package/src/index.ts

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+
+import packageJson from "../package.json" with { type: "json" };
+import { getProfile } from "./clients/user";
+import { init } from "./commands/init";
+import { login } from "./commands/login";
+import { logout } from "./commands/logout";
+import { sync } from "./commands/sync";
+import { whoami } from "./commands/whoami";
+import { getFramework } from "./frameworks";
+import { getHost, refreshToken } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { ForbiddenRequestError, UnauthorizedRequestError } from "./lib/request";
+import {
+	initSegment,
+	segmentIdentify,
+	segmentSetRepository,
+	segmentTrackEnd,
+	segmentTrackStart,
+} from "./lib/segment";
+import {
+	sentryCaptureError,
+	sentrySetContext,
+	sentrySetTag,
+	sentrySetUser,
+	setupSentry,
+} from "./lib/sentry";
+
+const HELP = `
+Prismic CLI for managing repositories and configurations.
+
+USAGE
+  prismic <command> [flags]
+
+COMMANDS
+  init        Initialize a Prismic project
+  sync        Sync types and slices from Prismic
+  login       Log in to Prismic
+  logout      Log out of Prismic
+  whoami      Show the currently logged in user
+
+FLAGS
+  -v, --version  Show CLI version
+  -h, --help     Show help for command
+
+LEARN MORE
+  Use \`prismic <command> --help\` for more information about a command.
+`.trim();
+
+const UNTRACKED_COMMANDS = new Set(["login", "logout", "whoami", "sync"]);
+const SKIP_REFRESH_COMMANDS = new Set(["login", "logout"]);
+
+const {
+	positionals,
+	values: { version },
+} = parseArgs({
+	options: {
+		help: { type: "boolean", short: "h" },
+		version: { type: "boolean", short: "v" },
+	},
+	allowPositionals: true,
+	strict: false,
+});
+
+setupSentry();
+await initSegment();
+
+if (version) {
+	console.info(packageJson.version);
+} else {
+	const command = positionals[0];
+
+	const repository = await safeGetRepositoryFromConfig();
+	if (repository) {
+		segmentSetRepository(repository);
+		sentrySetTag("repository", repository);
+		sentrySetContext("Repository Data", { name: repository });
+	}
+
+	const framework = await getFramework();
+	if (framework) {
+		sentrySetTag("framework", framework.id);
+	}
+
+	if (!SKIP_REFRESH_COMMANDS.has(command)) {
+		// Refreesh the token and identify the user in the background.
+		refreshToken()
+			.then(async (token) => {
+				if (!token) return;
+				const host = await getHost();
+				const profile = await getProfile({ token, host });
+				segmentIdentify({ shortId: profile.shortId, intercomHash: profile.intercomHash });
+				sentrySetUser({ id: profile.shortId });
+			})
+			.catch(() => {});
+	}
+
+	if (!UNTRACKED_COMMANDS.has(command)) {
+		segmentTrackStart(command, { repository });
+	}
+
+	try {
+		switch (command) {
+			case "init":
+				await init();
+				break;
+			case "sync":
+				await sync();
+				break;
+			case "login":
+				await login();
+				break;
+			case "logout":
+				await logout();
+				break;
+			case "whoami":
+				await whoami();
+				break;
+			default: {
+				if (command) {
+					console.error(`Unknown command: ${command}`);
+					process.exitCode = 1;
+				}
+				console.info(HELP);
+			}
+		}
+
+		if (!UNTRACKED_COMMANDS.has(command)) {
+			segmentTrackEnd(command, process.exitCode !== 1);
+		}
+	} catch (error) {
+		if (!UNTRACKED_COMMANDS.has(command)) {
+			segmentTrackEnd(command, false, error);
+		}
+		process.exitCode = 1;
+
+		if (error instanceof UnauthorizedRequestError || error instanceof ForbiddenRequestError) {
+			console.error("Not logged in. Run `prismic login` first.");
+		} else {
+			await sentryCaptureError(error);
+			throw error;
+		}
+	}
+}

package/src/lib/auth.ts

@@ -0,0 +1,176 @@
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { pathToFileURL } from "node:url";
+import * as v from "valibot";
+
+import { refreshToken as baseRefreshToken } from "../clients/auth";
+import { env } from "../env";
+import { exists } from "./file";
+import { stringify } from "./json";
+import { appendTrailingSlash } from "./url";
+
+const AUTH_FILE_PATH = new URL(".prismic", appendTrailingSlash(pathToFileURL(homedir())));
+const LOGIN_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes
+const PREFERRED_PORT = 5555;
+const LOGIN_SOURCE = "prismic-cli";
+
+const AuthFileSchema = v.object({
+	token: v.optional(v.pipe(v.string(), v.nonEmpty())),
+	host: v.optional(v.pipe(v.string(), v.nonEmpty())),
+});
+type AuthFile = v.InferOutput<typeof AuthFileSchema>;
+
+export async function getToken(): Promise<string | undefined> {
+	const auth = await readAuthFile();
+	return auth?.token;
+}
+
+export async function getHost(): Promise<string | undefined> {
+	const auth = await readAuthFile();
+	return auth?.host;
+}
+
+export async function refreshToken(): Promise<string | undefined> {
+	const auth = await readAuthFile();
+	const token = auth?.token;
+	const host = auth?.host;
+	if (!token) return;
+	const newToken = await baseRefreshToken(token, { host });
+	await saveAuthFile({ token: newToken, host });
+	return newToken;
+}
+
+export async function logout(): Promise<boolean> {
+	const authFileExists = await exists(AUTH_FILE_PATH);
+	if (!authFileExists) return true;
+
+	try {
+		await rm(AUTH_FILE_PATH, { force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function readAuthFile(): Promise<AuthFile | undefined> {
+	try {
+		const contents = await readFile(AUTH_FILE_PATH, "utf-8");
+		const json = JSON.parse(contents);
+		return v.parse(AuthFileSchema, json);
+	} catch {
+		return undefined;
+	}
+}
+
+async function saveAuthFile(auth: AuthFile): Promise<void> {
+	await writeFile(AUTH_FILE_PATH, stringify(auth));
+}
+
+export async function createLoginSession(options?: {
+	onReady?: (url: URL) => void;
+}): Promise<{ email: string }> {
+	const host = env.PRISMIC_HOST;
+	const corsOrigin = `https://${host}`;
+
+	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 saveAuthFile({ token, host });
+
+						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 = async (): Promise<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 = await 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);
+	});
+}
+
+async function buildLoginUrl(host: string, port: number): Promise<URL> {
+	const url = new URL("dashboard/cli/login", `https://${host}/`);
+	url.searchParams.set("source", LOGIN_SOURCE);
+	url.searchParams.set("port", port.toString());
+	return url;
+}

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()),
+		}),
+	),
+});
+export 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/error.ts

@@ -0,0 +1,3 @@
+export class NotFoundError extends Error {}
+export class ForbiddenError extends Error {}
+export class UnauthorizedError extends Error {}