prismic 0.0.0-pr.28.59bf330

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,155 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+
+import packageJson from "../package.json" with { type: "json" };
+import { codegen } from "./codegen";
+import { customType } from "./custom-type";
+import { docs } from "./docs";
+import { initSegment, trackEnd, trackStart } from "./lib/segment";
+import { captureError, setupSentry } from "./lib/sentry";
+import { init } from "./init";
+import { locale } from "./locale";
+import { login } from "./login";
+import { logout } from "./logout";
+import { pageType } from "./page-type";
+import { preview } from "./preview";
+import { pull } from "./pull";
+import { push } from "./push";
+import { repo } from "./repo";
+import { slice } from "./slice";
+import { status } from "./status";
+import { sync } from "./sync";
+import { token } from "./token";
+import { webhook } from "./webhook";
+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
+  status      Show the status of the current project
+  repo        Manage Prismic repositories
+  locale      Manage locales in a repository
+  page-type   Manage page types in a repository
+  custom-type Manage custom types in a repository
+  slice       Manage slices in a project
+  pull        Pull types and slices from Prismic
+  push        Push types and slices to Prismic
+  codegen     Generate code from Prismic models
+  docs        Fetch and list documentation from Prismic
+  preview     Manage preview configurations
+  token       Manage API tokens in a repository
+  webhook     Manage webhooks in a repository
+
+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;
+			case "status":
+				await status();
+				break;
+			case "repo":
+				await repo();
+				break;
+			case "locale":
+				await locale();
+				break;
+			case "page-type":
+				await pageType();
+				break;
+			case "custom-type":
+				await customType();
+				break;
+			case "slice":
+				await slice();
+				break;
+			case "pull":
+				await pull();
+				break;
+			case "push":
+				await push();
+				break;
+			case "codegen":
+				await codegen();
+				break;
+			case "docs":
+				await docs();
+				break;
+			case "preview":
+				await preview();
+				break;
+			case "token":
+				await token();
+				break;
+			case "webhook":
+				await webhook();
+				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.`,
+	);
+}