prismic 0.0.0-canary.2cfb4a8

package/src/framework/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,90 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+
+import packageJson from "../package.json" with { type: "json" };
+import { init } from "./init";
+import { initSegment, trackEnd, trackStart } from "./lib/segment";
+import { captureError, setupSentry } from "./lib/sentry";
+import { login } from "./login";
+import { logout } from "./logout";
+import { sync } from "./sync";
+import { whoami } from "./whoami";
+
+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 {
+	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];
+
+	trackStart(command);
+
+	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);
+			}
+		}
+
+		trackEnd(command, process.exitCode !== 1);
+	} catch (error) {
+		await captureError(error);
+		trackEnd(command, false, error);
+		process.exitCode = 1;
+		throw error;
+	}
+}

package/src/init.ts

@@ -0,0 +1,173 @@
+import { readFile, rm } from "node:fs/promises";
+import { parseArgs } from "node:util";
+import * as v from "valibot";
+
+import { createLoginSession, isAuthenticated } from "./lib/auth";
+import { openBrowser } from "./lib/browser";
+import { createConfig, readConfig, UnknownProjectRoot } from "./lib/config";
+import { findUpward } from "./lib/file";
+import { getFramework } from "./framework";
+import { request } from "./lib/request";
+import { getUserServiceUrl } from "./lib/url";
+import { syncCustomTypes, syncSlices } from "./sync";
+
+const HELP = `
+Initialize a Prismic project by creating a prismic.config.json file.
+
+Detects the project framework, installs dependencies, and syncs models
+from Prismic. If a slicemachine.config.json exists, it will be migrated.
+
+USAGE
+  prismic init [flags]
+
+FLAGS
+  -r, --repo string   Repository name
+  -h, --help          Show help for command
+
+EXAMPLES
+  prismic init --repo my-repo
+
+LEARN MORE
+  Use \`prismic <command> --help\` for more information about a command.
+`.trim();
+
+const ProfileSchema = v.object({
+	repositories: v.array(
+		v.object({
+			domain: v.string(),
+			name: v.optional(v.string()),
+		}),
+	),
+});
+
+export async function init(): Promise<void> {
+	const { values } = parseArgs({
+		args: process.argv.slice(3),
+		options: {
+			help: { type: "boolean", short: "h" },
+			repo: { type: "string", short: "r" },
+		},
+	});
+
+	if (values.help) {
+		console.info(HELP);
+		return;
+	}
+
+	// Check for existing prismic.config.json
+	const existingConfig = await readConfig();
+	if (existingConfig.ok) {
+		console.error("A prismic.config.json file already exists.");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Check for legacy slicemachine.config.json
+	const legacyConfigPath = await findUpward("slicemachine.config.json", {
+		stop: "package.json",
+	});
+	let legacyRepoName: string | undefined;
+	let legacyLibraries: string[] | undefined;
+
+	if (legacyConfigPath) {
+		try {
+			const contents = await readFile(legacyConfigPath, "utf8");
+			const legacyConfig = JSON.parse(contents);
+			legacyRepoName = legacyConfig.repositoryName;
+			legacyLibraries = legacyConfig.libraries;
+		} catch {
+			console.warn("Could not read slicemachine.config.json, ignoring.");
+		}
+	}
+
+	// Determine repo name: --repo flag > legacy config > error
+	const repo = values.repo ?? legacyRepoName;
+	if (!repo) {
+		console.error("Missing required flag: --repo");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Login if needed
+	if (!(await isAuthenticated())) {
+		console.info("Not logged in. Starting login...");
+		const { email } = await createLoginSession({
+			onReady: (url) => {
+				console.info("Opening browser to complete login...");
+				console.info(`If the browser doesn't open, visit: ${url}`);
+				openBrowser(url);
+			},
+		});
+		console.info(`Logged in as ${email}`);
+	}
+
+	// Validate repo membership
+	const profileUrl = new URL("profile", await getUserServiceUrl());
+	const profileResponse = await request(profileUrl, {
+		schema: ProfileSchema,
+	});
+	if (!profileResponse.ok) {
+		console.error("Failed to fetch user profile.");
+		process.exitCode = 1;
+		return;
+	}
+
+	const repoData = profileResponse.value.repositories.find(
+		(r) => r.domain === repo,
+	);
+	if (!repoData) {
+		console.error(
+			`Repository "${repo}" not found in your account. Check the name or create it with \`prismic repo create\`.`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	// Detect framework
+	const framework = await getFramework();
+	if (!framework) {
+		console.error(
+			"Could not detect a supported framework (Next.js, Nuxt, or SvelteKit).",
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	// Create prismic.config.json
+	const configData: { repositoryName: string; libraries?: string[] } = {
+		repositoryName: repo,
+	};
+	if (legacyLibraries?.length) {
+		configData.libraries = legacyLibraries;
+	}
+
+	const configResult = await createConfig(configData);
+	if (!configResult.ok) {
+		if (configResult.error instanceof UnknownProjectRoot) {
+			console.error(
+				"Could not find a package.json file. Run this command from a project directory.",
+			);
+		} else {
+			console.error("Failed to create config file.");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	// Delete legacy config after new config is created
+	if (legacyConfigPath) {
+		await rm(legacyConfigPath);
+		console.info("Migrated slicemachine.config.json to prismic.config.json");
+	}
+
+	// Install dependencies and create framework files
+	await framework.initProject();
+
+	// Sync models from remote
+	await syncSlices(repo, framework);
+	await syncCustomTypes(repo, framework);
+
+	console.info(
+		`Initialized Prismic for repository "${repo}". Run \`npm install\` to install new dependencies.`,
+	);
+}

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