prismic 1.2.1 → 1.3.0

package/src/adapters/sveltekit.templates.ts

@@ -1,3 +1,5 @@
+import type { CustomType } from "@prismicio/types-internal/lib/customtypes";
+
 import { pascalCase } from "change-case";
 
 import { dedent } from "../lib/string";
@@ -7,7 +9,7 @@ export function prismicIOFileTemplate(args: { typescript: boolean }): string {
 
 	if (typescript) {
 		return dedent`
-			import { createClient as baseCreateClient, type Route } from "@prismicio/client";
+			import { createClient as baseCreateClient } from "@prismicio/client";
 			import { type CreateClientConfig, enableAutoPreviews } from '@prismicio/svelte/kit';
 			import prismicConfig from "../../prismic.config.json";
 
@@ -16,21 +18,6 @@ export function prismicIOFileTemplate(args: { typescript: boolean }): string {
 			 */
 			export const repositoryName = prismicConfig.repositoryName;
 
-			/**
-			 * A list of Route Resolver objects that define how a document's \`url\` field is resolved.
-			 *
-			 * {@link https://prismic.io/docs/route-resolver}
-			 *
-			 * Note: \`prismic sync\` may append new default routes for Page Types. Feel free
-			 * to edit these to match your site's routing structure.
-			 */
-			// TODO: Update the routes array to match your project's route structure.
-			const routes: Route[] = [
-				// Examples:
-				// { type: "homepage", path: "/" },
-				// { type: "page", path: "/:uid" },
-			];
-
 			/**
 			 * Creates a Prismic client for the project's repository. The client is used to
 			 * query content from the Prismic API.
@@ -39,7 +26,7 @@ export function prismicIOFileTemplate(args: { typescript: boolean }): string {
 			 */
 			export const createClient = ({ cookies, ...config }: CreateClientConfig = {}) => {
 				const client = baseCreateClient(repositoryName, {
-					routes,
+					routes: prismicConfig.routes,
 					...config,
 				});
 
@@ -60,23 +47,6 @@ export function prismicIOFileTemplate(args: { typescript: boolean }): string {
 		 */
 		export const repositoryName = prismicConfig.repositoryName;
 
-		/**
-		 * A list of Route Resolver objects that define how a document's \`url\` field is resolved.
-		 *
-		 * {@link https://prismic.io/docs/route-resolver#route-resolver}
-		 *
-		 * Note: \`prismic sync\` may append new default routes for Page Types. Feel free
-		 * to edit these to match your site's routing structure.
-		 *
-		 * @type {import("@prismicio/client").Route[]}
-		 */
-		// TODO: Update the routes array to match your project's route structure.
-		const routes = [
-			// Examples:
-			// { type: "homepage", path: "/" },
-			// { type: "page", path: "/:uid" },
-		];
-
 		/**
 		 * Creates a Prismic client for the project's repository. The client is used to
 		 * query content from the Prismic API.
@@ -85,7 +55,7 @@ export function prismicIOFileTemplate(args: { typescript: boolean }): string {
 		 */
 		export const createClient = ({ cookies, ...config } = {}) => {
 			const client = baseCreateClient(repositoryName, {
-				routes,
+				routes: prismicConfig.routes,
 				...config,
 			});
 
@@ -209,6 +179,93 @@ export function rootLayoutTemplate(args: { version: number }): string {
 	return version <= 4 ? v4 : v5;
 }
 
+export function pageTemplate(args: { typescript: boolean }): string {
+	const { typescript } = args;
+
+	if (typescript) {
+		return dedent`
+			<script lang="ts">
+				import { SliceZone } from "@prismicio/svelte";
+				import { components } from "$lib/slices";
+				import type { PageProps } from "./$types";
+
+				const { data }: PageProps = $props();
+			</script>
+
+			<SliceZone slices={data.page.data.slices} {components} />
+		`;
+	}
+
+	return dedent`
+		<script>
+			import { SliceZone } from "@prismicio/svelte";
+			import { components } from "$lib/slices";
+
+			const { data } = $props();
+		</script>
+
+		<SliceZone slices={data.page.data.slices} {components} />
+	`;
+}
+
+export function pageServerTemplate(args: { model: CustomType; typescript: boolean }): string {
+	const { model, typescript } = args;
+
+	if (model.repeatable) {
+		if (typescript) {
+			return dedent`
+				import type { PageServerLoad } from "./$types";
+				import { createClient } from "$lib/prismicio";
+
+				export const load: PageServerLoad = async ({ params, fetch, cookies }) => {
+					const client = createClient({ fetch, cookies });
+					const page = await client.getByUID("${model.id}", params.uid);
+
+					return { page };
+				};
+			`;
+		}
+
+		return dedent`
+			import { createClient } from "$lib/prismicio";
+
+			/** @type {import("./$types").PageServerLoad} */
+			export async function load({ params, fetch, cookies }) {
+				const client = createClient({ fetch, cookies });
+				const page = await client.getByUID("${model.id}", params.uid);
+
+				return { page };
+			}
+		`;
+	}
+
+	if (typescript) {
+		return dedent`
+			import type { PageServerLoad } from "./$types";
+			import { createClient } from "$lib/prismicio";
+
+			export const load: PageServerLoad = async ({ fetch, cookies }) => {
+				const client = createClient({ fetch, cookies });
+				const page = await client.getSingle("${model.id}");
+
+				return { page };
+			};
+		`;
+	}
+
+	return dedent`
+		import { createClient } from "$lib/prismicio";
+
+		/* @type {import("./$types").PageServerLoad} */
+		export async function load({ fetch, cookies }) {
+			const client = createClient({ fetch, cookies });
+			const page = await client.getSingle("${model.id}");
+
+			return { page };
+		}
+	`;
+}
+
 const SLICE_MARKUP = dedent`
 <section data-slice-type={slice.slice_type} data-slice-variation={slice.variation}>
 	Placeholder component for {slice.slice_type} (variation: {slice.variation}) slices.

package/src/adapters/sveltekit.ts

@@ -1,4 +1,4 @@
-import type { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+import type { CustomType, SharedSlice } from "@prismicio/types-internal/lib/customtypes";
 
 import { pascalCase } from "change-case";
 import { loadFile } from "magicast";
@@ -8,12 +8,15 @@ import { relative } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { Adapter } from ".";
+import { buildRoutePath } from "../config";
 import { exists, writeFileRecursive } from "../lib/file";
 import { addDependencies, findPackageJson, getNpmPackageVersion } from "../lib/packageJson";
 import { dedent } from "../lib/string";
 import { appendTrailingSlash } from "../lib/url";
 import { checkIsTypeScriptProject, findProjectRoot } from "../project";
 import {
+	pageServerTemplate,
+	pageTemplate,
 	previewAPIRouteTemplate,
 	prismicIOFileTemplate,
 	rootLayoutTemplate,
@@ -24,7 +27,7 @@ import {
 export class SvelteKitAdapter extends Adapter {
 	readonly id = "sveltekit";
 
-	async onProjectInitialized(): Promise<void> {
+	async setupProject(): Promise<void> {
 		await addDependencies({
 			"@prismicio/client": `^${await getNpmPackageVersion("@prismicio/client")}`,
 			"@prismicio/svelte": `^${await getNpmPackageVersion("@prismicio/svelte")}`,
@@ -39,6 +42,8 @@ export class SvelteKitAdapter extends Adapter {
 		await modifyViteConfig();
 	}
 
+	onProjectInitialized(): void {}
+
 	async onSliceCreated(model: SharedSlice, library: URL): Promise<void> {
 		const sliceDirectoryName = pascalCase(model.name);
 		const sliceDirectory = new URL(sliceDirectoryName, appendTrailingSlash(library));
@@ -56,7 +61,9 @@ export class SvelteKitAdapter extends Adapter {
 
 	onSliceDeleted(): void {}
 
-	onCustomTypeCreated(): void {}
+	async onCustomTypeCreated(model: CustomType): Promise<void> {
+		if (model.format === "page") await createPageFile(model);
+	}
 
 	onCustomTypeUpdated(): void {}
 
@@ -183,6 +190,34 @@ async function createRootLayoutFile(): Promise<void> {
 	await writeFileRecursive(filePath, contents);
 }
 
+async function createPageFile(model: CustomType): Promise<void> {
+	const routePath = buildRoutePath(model)
+		.split("/")
+		.filter(Boolean)
+		.map((segment) => (segment.startsWith(":") ? `[${segment.slice(1)}]` : segment))
+		.join("/");
+	const projectRoot = await findProjectRoot();
+	const extension = await getJsFileExtension();
+	const fullRoutePath = new URL(`src/routes/[[preview=preview]]/${routePath}/`, projectRoot);
+
+	const pageFilePath = new URL("+page.svelte", fullRoutePath);
+	if (!(await exists(pageFilePath))) {
+		const contents = pageTemplate({
+			typescript: await checkIsTypeScriptProject(),
+		});
+		await writeFileRecursive(pageFilePath, contents);
+	}
+
+	const serverFilePath = new URL(`+page.server.${extension}`, fullRoutePath);
+	if (!(await exists(serverFilePath))) {
+		const contents = pageServerTemplate({
+			model,
+			typescript: await checkIsTypeScriptProject(),
+		});
+		await writeFileRecursive(serverFilePath, contents);
+	}
+}
+
 async function modifyViteConfig(): Promise<void> {
 	const projectRoot = await findProjectRoot();
 	let configUrl = new URL("vite.config.js", projectRoot);

package/src/auth.ts

@@ -5,7 +5,7 @@ import { pathToFileURL } from "node:url";
 import * as z from "zod/mini";
 
 import { refreshToken as baseRefreshToken } from "./clients/auth";
-import { env } from "./env";
+import { DEFAULT_PRISMIC_HOST, env } from "./env";
 import { exists } from "./lib/file";
 import { stringify } from "./lib/json";
 import { appendTrailingSlash } from "./lib/url";
@@ -14,7 +14,6 @@ const AUTH_FILE_PATH = new URL(".prismic", appendTrailingSlash(pathToFileURL(hom
 const LOGIN_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes
 const PREFERRED_PORT = 5555;
 const LOGIN_SOURCE = "prismic-cli";
-const DEFAULT_PRISMIC_HOST = "prismic.io";
 
 const AuthFileSchema = z.object({
 	token: z.optional(z.string().check(z.minLength(1))),

package/src/clients/locale.ts

@@ -0,0 +1,64 @@
+import * as z from "zod/mini";
+
+import { request } from "../lib/request";
+
+const LocaleSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	customName: z.nullable(z.string()),
+	isMaster: z.boolean(),
+});
+
+export type Locale = z.infer<typeof LocaleSchema>;
+
+export async function getLocales(config: {
+	repo: string;
+	token: string | undefined;
+	host: string;
+}): Promise<Locale[]> {
+	const { repo, token, host } = config;
+	const url = new URL("repository/locales", getLocaleServiceUrl(host));
+	url.searchParams.set("repository", repo);
+	const response = await request(url, {
+		headers: { Authorization: `Bearer ${token}` },
+		schema: z.object({ results: z.array(LocaleSchema) }),
+	});
+	return response.results;
+}
+
+export async function upsertLocale(
+	locale: { id: string; isMaster?: boolean; customName?: string },
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<Locale> {
+	const { repo, token, host } = config;
+	const url = new URL("repository/locales", getLocaleServiceUrl(host));
+	url.searchParams.set("repository", repo);
+	const response = await request(url, {
+		method: "POST",
+		body: {
+			id: locale.id,
+			isMaster: locale.isMaster ?? false,
+			...(locale.customName ? { customName: locale.customName } : {}),
+		},
+		headers: { Authorization: `Bearer ${token}` },
+		schema: LocaleSchema,
+	});
+	return response;
+}
+
+export async function removeLocale(
+	code: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const url = new URL(`repository/locales/${encodeURIComponent(code)}`, getLocaleServiceUrl(host));
+	url.searchParams.set("repository", repo);
+	await request(url, {
+		method: "DELETE",
+		headers: { Authorization: `Bearer ${token}` },
+	});
+}
+
+function getLocaleServiceUrl(host: string): URL {
+	return new URL(`https://api.internal.${host}/locale/`);
+}

package/src/clients/user.ts

@@ -10,6 +10,7 @@ const ProfileSchema = z.object({
 		z.object({
 			domain: z.string(),
 			name: z.optional(z.string()),
+			role: z.optional(z.string()),
 		}),
 	),
 });

package/src/clients/wroom.ts

@@ -106,6 +106,218 @@ export async function deleteWebhook(
 	});
 }
 
+const AccessTokenSchema = z.object({
+	id: z.string(),
+	scope: z.string(),
+	token: z.string(),
+	created_at: z.object({ $date: z.number() }),
+});
+type AccessToken = z.infer<typeof AccessTokenSchema>;
+
+const OAuthAppSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	wroom_auths: z.array(AccessTokenSchema),
+});
+type OAuthApp = z.infer<typeof OAuthAppSchema>;
+
+const WriteTokenSchema = z.object({
+	app_name: z.string(),
+	token: z.string(),
+	timestamp: z.number(),
+});
+type WriteToken = z.infer<typeof WriteTokenSchema>;
+
+const WriteTokensInfoSchema = z.object({
+	max_tokens: z.number(),
+	tokens: z.array(WriteTokenSchema),
+});
+type WriteTokensInfo = z.infer<typeof WriteTokensInfoSchema>;
+
+export async function getOAuthApps(config: {
+	repo: string;
+	token: string | undefined;
+	host: string;
+}): Promise<OAuthApp[]> {
+	const url = new URL("settings/security/contentapi", getWroomUrl(config.repo, config.host));
+	return await request(url, {
+		credentials: { "prismic-auth": config.token },
+		schema: z.array(OAuthAppSchema),
+	});
+}
+
+export async function createOAuthApp(
+	name: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<OAuthApp> {
+	const url = new URL("settings/security/oauthapp", getWroomUrl(config.repo, config.host));
+	return await request(url, {
+		method: "POST",
+		body: { app_name: name },
+		credentials: { "prismic-auth": config.token },
+		schema: OAuthAppSchema,
+	});
+}
+
+export async function createOAuthAuthorization(
+	appId: string,
+	scope: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<AccessToken> {
+	const url = new URL("settings/security/authorizations", getWroomUrl(config.repo, config.host));
+	return await request(url, {
+		method: "POST",
+		body: { app: appId, scope },
+		credentials: { "prismic-auth": config.token },
+		schema: AccessTokenSchema,
+	});
+}
+
+export async function deleteOAuthAuthorization(
+	authId: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const url = new URL(
+		`settings/security/authorizations/${encodeURIComponent(authId)}`,
+		getWroomUrl(config.repo, config.host),
+	);
+	await request(url, {
+		method: "DELETE",
+		credentials: { "prismic-auth": config.token },
+	});
+}
+
+export async function getWriteTokens(config: {
+	repo: string;
+	token: string | undefined;
+	host: string;
+}): Promise<WriteTokensInfo> {
+	const url = new URL("settings/security/customtypesapi", getWroomUrl(config.repo, config.host));
+	return await request(url, {
+		credentials: { "prismic-auth": config.token },
+		schema: WriteTokensInfoSchema,
+	});
+}
+
+export async function createWriteToken(
+	name: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<WriteToken> {
+	const url = new URL("settings/security/token", getWroomUrl(config.repo, config.host));
+	return await request(url, {
+		method: "POST",
+		body: { app_name: name },
+		credentials: { "prismic-auth": config.token },
+		schema: WriteTokenSchema,
+	});
+}
+
+export async function deleteWriteToken(
+	tokenValue: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const url = new URL(
+		`settings/security/token/${encodeURIComponent(tokenValue)}`,
+		getWroomUrl(config.repo, config.host),
+	);
+	await request(url, {
+		method: "DELETE",
+		credentials: { "prismic-auth": config.token },
+	});
+}
+
+export async function checkIsDomainAvailable(config: {
+	domain: string;
+	token: string | undefined;
+	host: string;
+}): Promise<boolean> {
+	const { domain, token, host } = config;
+	const url = new URL(`app/dashboard/repositories/${domain}/exists`, getDashboardUrl(host));
+	const response = await request(url, {
+		credentials: { "prismic-auth": token },
+		schema: z.boolean(),
+	});
+	return response;
+}
+
+export async function createRepository(config: {
+	domain: string;
+	name: string;
+	framework: string;
+	token: string | undefined;
+	host: string;
+}): Promise<void> {
+	const { domain, name, framework, token, host } = config;
+	const url = new URL("app/dashboard/repositories", getDashboardUrl(host));
+	await request(url, {
+		method: "POST",
+		body: { domain, name, framework, plan: "personal" },
+		credentials: { "prismic-auth": token },
+	});
+}
+
+const SyncStateSchema = z.object({
+	repository: z.object({
+		api_access: z.string(),
+	}),
+});
+
+export async function getRepositoryAccess(config: {
+	repo: string;
+	token: string | undefined;
+	host: string;
+}): Promise<string> {
+	const { repo, token, host } = config;
+	const url = new URL("syncState", getWroomUrl(repo, host));
+	const response = await request(url, {
+		credentials: { "prismic-auth": token },
+		schema: SyncStateSchema,
+	});
+	return response.repository.api_access;
+}
+
+export type RepositoryAccessLevel = "private" | "public" | "open";
+
+export async function setRepositoryAccess(
+	level: RepositoryAccessLevel,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const url = new URL("settings/security/apiaccess", getWroomUrl(repo, host));
+	await request(url, {
+		method: "POST",
+		body: { api_access: level },
+		credentials: { "prismic-auth": token },
+	});
+}
+
+const SetNameResponseSchema = z.object({
+	repository: z.object({
+		name: z.string(),
+	}),
+});
+
+export async function setRepositoryName(
+	name: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<string> {
+	const { repo, token, host } = config;
+	const url = new URL("app/settings/repository", getWroomUrl(repo, host));
+	const formData = new FormData();
+	formData.set("displayname", name);
+	const response = await request(url, {
+		method: "POST",
+		body: formData,
+		credentials: { "prismic-auth": token },
+		schema: SetNameResponseSchema,
+	});
+	return response.repository.name;
+}
+
+function getDashboardUrl(host: string): URL {
+	return new URL(`https://${host}/`);
+}
+
 function getWroomUrl(repo: string, host: string): URL {
 	return new URL(`https://${repo}.${host}/`);
 }

package/src/commands/gen-setup.ts

@@ -0,0 +1,38 @@
+import { getAdapter } from "../adapters";
+import { createCommand, type CommandConfig } from "../lib/command";
+import { installDependencies } from "../lib/packageJson";
+
+const config = {
+	name: "prismic gen setup",
+	description: `
+		Generate framework-specific setup files for a Prismic project.
+
+		Installs dependencies, creates the Prismic client file, slice simulator
+		page, preview routes, and other files required by the detected framework.
+		Skips files that already exist.
+	`,
+	options: {
+		"no-install": {
+			type: "boolean",
+			description: "Skip installing dependencies",
+		},
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ values }) => {
+	const adapter = await getAdapter();
+	await adapter.setupProject();
+
+	if (!values["no-install"]) {
+		try {
+			console.info("Installing dependencies...");
+			await installDependencies();
+		} catch {
+			console.warn(
+				"Could not install dependencies automatically. Please install them manually (i.e. `npm install`).",
+			);
+		}
+	}
+
+	console.info("Generated setup files.");
+});

package/src/commands/gen-types.ts

@@ -0,0 +1,35 @@
+import { getAdapter } from "../adapters";
+import { generateAndWriteTypes } from "../lib/codegen";
+import { createCommand, type CommandConfig } from "../lib/command";
+import { relativePathname } from "../lib/url";
+import { findProjectRoot } from "../project";
+
+const FILENAME = "prismicio-types.d.ts";
+
+const config = {
+	name: "prismic gen types",
+	description: `
+		Generate TypeScript types from local custom type and slice models.
+
+		Reads models from the customtypes/ and slices directories, then writes
+		a prismicio-types.d.ts file at the project root.
+	`,
+} satisfies CommandConfig;
+
+export default createCommand(config, async () => {
+	const adapter = await getAdapter();
+	const slices = await adapter.getSlices();
+	const customTypes = await adapter.getCustomTypes();
+	const projectRoot = await findProjectRoot();
+
+	const output = new URL(FILENAME, projectRoot);
+	const relativeOutput = relativePathname(projectRoot, output);
+
+	await generateAndWriteTypes({
+		customTypes: customTypes.map((customType) => customType.model),
+		slices: slices.map((slice) => slice.model),
+		output,
+	});
+
+	console.info(`Generated types at ${relativeOutput}`);
+});

package/src/commands/gen.ts

@@ -0,0 +1,18 @@
+import { createCommandRouter } from "../lib/command";
+import genSetup from "./gen-setup";
+import genTypes from "./gen-types";
+
+export default createCommandRouter({
+	name: "prismic gen",
+	description: "Generate files from local Prismic models.",
+	commands: {
+		setup: {
+			handler: genSetup,
+			description: "Generate framework-specific Prismic setup",
+		},
+		types: {
+			handler: genTypes,
+			description: "Generate TypeScript types from local models",
+		},
+	},
+});

package/src/commands/init.ts

@@ -12,6 +12,7 @@ import {
 	readLegacySliceMachineConfig,
 	UnknownProjectRoot,
 } from "../config";
+import { DEFAULT_PRISMIC_HOST } from "../env";
 import { openBrowser } from "../lib/browser";
 import { generateAndWriteTypes } from "../lib/codegen";
 import { CommandError, createCommand, type CommandConfig } from "../lib/command";
@@ -108,9 +109,13 @@ export default createCommand(config, async ({ values }) => {
 
 	// Create prismic.config.json
 	try {
+		const documentAPIEndpoint =
+			host !== DEFAULT_PRISMIC_HOST ? `https://${repo}.cdn.${host}/api/v2/` : undefined;
 		await createConfig({
 			repositoryName: repo,
+			documentAPIEndpoint,
 			libraries: legacySliceMachineConfig?.libraries,
+			routes: [],
 		});
 	} catch (error) {
 		if (error instanceof UnknownProjectRoot) {
@@ -149,10 +154,11 @@ export default createCommand(config, async ({ values }) => {
 	const slices = await adapter.getSlices();
 	const customTypes = await adapter.getCustomTypes();
 	const projectRoot = await findProjectRoot();
+	const output = new URL("prismicio-types.d.ts", projectRoot);
 	await generateAndWriteTypes({
 		customTypes: customTypes.map((customType) => customType.model),
 		slices: slices.map((slice) => slice.model),
-		projectRoot,
+		output,
 	});
 
 	console.info(`\nInitialized Prismic for repository "${repo}".`);