feat: add remote modeling commands for custom types, page types, and slices

src/adapters/index.ts

@@ -6,6 +6,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { generateTypes } from "prismic-ts-codegen";
 import { glob } from "tinyglobby";
 
+import { getCustomTypes, getSlices } from "../clients/custom-types";
 import { addRoute, removeRoute, updateRoute } from "../project";
 import { readJsonFile, writeFileRecursive } from "../lib/file";
 import { stringify } from "../lib/json";
@@ -180,6 +181,89 @@ export abstract class Adapter {
 		await this.onCustomTypeDeleted(id);
 	}
 
+	async syncModels(config: {
+		repo: string;
+		token: string | undefined;
+		host: string;
+	}): Promise<void> {
+		const { repo, token, host } = config;
+		await Promise.all([
+			this.syncSlices({ repo, token, host, generateTypes: false }),
+			this.syncCustomTypes({ repo, token, host, generateTypes: false }),
+		]);
+		await this.generateTypes();
+	}
+
+	async syncSlices(config: {
+		repo: string;
+		token: string | undefined;
+		host: string;
+		generateTypes?: boolean;
+	}): Promise<void> {
+		const { repo, token, host, generateTypes = true } = config;
+
+		const remoteSlices = await getSlices({ repo, token, host });
+		const localSlices = await this.getSlices();
+
+		// Handle slices update
+		for (const remoteSlice of remoteSlices) {
+			const localSlice = localSlices.find((slice) => slice.model.id === remoteSlice.id);
+			if (localSlice) await this.updateSlice(remoteSlice);
+		}
+
+		// Handle slices deletion
+		for (const localSlice of localSlices) {
+			const existsRemotely = remoteSlices.some((slice) => slice.id === localSlice.model.id);
+			if (!existsRemotely) await this.deleteSlice(localSlice.model.id);
+		}
+
+		// Handle slices creation
+		for (const remoteSlice of remoteSlices) {
+			const existsLocally = localSlices.some((slice) => slice.model.id === remoteSlice.id);
+			if (!existsLocally) await this.createSlice(remoteSlice);
+		}
+
+		if (generateTypes) await this.generateTypes();
+	}
+
+	async syncCustomTypes(config: {
+		repo: string;
+		token: string | undefined;
+		host: string;
+		generateTypes?: boolean;
+	}): Promise<void> {
+		const { repo, token, host, generateTypes = true } = config;
+
+		const remoteCustomTypes = await getCustomTypes({ repo, token, host });
+		const localCustomTypes = await this.getCustomTypes();
+
+		// Handle custom types update
+		for (const remoteCustomType of remoteCustomTypes) {
+			const localCustomType = localCustomTypes.find(
+				(customType) => customType.model.id === remoteCustomType.id,
+			);
+			if (localCustomType) await this.updateCustomType(remoteCustomType);
+		}
+
+		// Handle custom types deletion
+		for (const localCustomType of localCustomTypes) {
+			const existsRemotely = remoteCustomTypes.some(
+				(customType) => customType.id === localCustomType.model.id,
+			);
+			if (!existsRemotely) await this.deleteCustomType(localCustomType.model.id);
+		}
+
+		// Handle custom types creation
+		for (const remoteCustomType of remoteCustomTypes) {
+			const existsLocally = localCustomTypes.some(
+				(customType) => customType.model.id === remoteCustomType.id,
+			);
+			if (!existsLocally) await this.createCustomType(remoteCustomType);
+		}
+
+		if (generateTypes) await this.generateTypes();
+	}
+
 	async generateTypes(): Promise<URL> {
 		const projectRoot = await findProjectRoot();
 		const output = new URL(TYPES_FILENAME, projectRoot);

src/clients/custom-types.ts

@@ -1,6 +1,10 @@
 import type { CustomType, SharedSlice } from "@prismicio/types-internal/lib/customtypes";
 
+import { createHash } from "node:crypto";
+import * as z from "zod/mini";
+
 import { NotFoundRequestError, request } from "../lib/request";
+import { appendTrailingSlash } from "../lib/url";
 
 export async function getCustomTypes(config: {
 	repo: string;
@@ -23,6 +27,66 @@ export async function getCustomTypes(config: {
 	}
 }
 
+export async function getCustomType(
+	id: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<CustomType> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL(`customtypes/${encodeURIComponent(id)}`, customTypesServiceUrl);
+	try {
+		return await request<CustomType>(url, {
+			headers: { repository: repo, Authorization: `Bearer ${token}` },
+		});
+	} catch (error) {
+		if (error instanceof NotFoundRequestError) {
+			error.message = `Type not found: ${id}`;
+		}
+		throw error;
+	}
+}
+
+export async function insertCustomType(
+	model: CustomType,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL("customtypes/insert", customTypesServiceUrl);
+	await request(url, {
+		method: "POST",
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+		body: model,
+	});
+}
+
+export async function updateCustomType(
+	model: CustomType,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL("customtypes/update", customTypesServiceUrl);
+	await request(url, {
+		method: "POST",
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+		body: model,
+	});
+}
+
+export async function removeCustomType(
+	id: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL(`customtypes/${encodeURIComponent(id)}`, customTypesServiceUrl);
+	await request(url, {
+		method: "DELETE",
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+	});
+}
+
 export async function getSlices(config: {
 	repo: string;
 	token: string | undefined;
@@ -44,6 +108,141 @@ export async function getSlices(config: {
 	}
 }
 
+export async function getSlice(
+	id: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<SharedSlice> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL(`slices/${encodeURIComponent(id)}`, customTypesServiceUrl);
+	try {
+		return await request<SharedSlice>(url, {
+			headers: { repository: repo, Authorization: `Bearer ${token}` },
+		});
+	} catch (error) {
+		if (error instanceof NotFoundRequestError) {
+			error.message = `Slice not found: ${id}`;
+		}
+		throw error;
+	}
+}
+
+export async function insertSlice(
+	model: SharedSlice,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL("slices/insert", customTypesServiceUrl);
+	await request(url, {
+		method: "POST",
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+		body: model,
+	});
+}
+
+export async function updateSlice(
+	model: SharedSlice,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL("slices/update", customTypesServiceUrl);
+	await request(url, {
+		method: "POST",
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+		body: model,
+	});
+}
+
+export async function removeSlice(
+	id: string,
+	config: { repo: string; token: string | undefined; host: string },
+): Promise<void> {
+	const { repo, token, host } = config;
+	const customTypesServiceUrl = getCustomTypesServiceUrl(host);
+	const url = new URL(`slices/${encodeURIComponent(id)}`, customTypesServiceUrl);
+	await request(url, {
+		method: "DELETE",
+		headers: { repository: repo, Authorization: `Bearer ${token}` },
+	});
+}
+
+const AclCreateResponseSchema = z.object({
+	values: z.object({
+		url: z.string(),
+		fields: z.record(z.string(), z.string()),
+	}),
+	imgixEndpoint: z.string(),
+});
+
+const SUPPORTED_IMAGE_MIME_TYPES: Record<string, string> = {
+	"image/png": ".png",
+	"image/jpeg": ".jpg",
+	"image/gif": ".gif",
+	"image/webp": ".webp",
+};
+
+export async function uploadScreenshot(
+	blob: Blob,
+	config: {
+		sliceId: string;
+		variationId: string;
+		repo: string;
+		token: string | undefined;
+		host: string;
+	},
+): Promise<URL> {
+	const { sliceId, variationId, repo, token, host } = config;
+
+	const type = blob.type;
+	if (!(type in SUPPORTED_IMAGE_MIME_TYPES)) {
+		throw new UnsupportedFileTypeError(type);
+	}
+
+	const aclUrl = new URL("create", getAclProviderUrl(host));
+	const acl = await request(aclUrl, {
+		headers: { Repository: repo, Authorization: `Bearer ${token}` },
+		schema: AclCreateResponseSchema,
+	});
+
+	const extension = SUPPORTED_IMAGE_MIME_TYPES[type];
+	const digest = createHash("md5")
+		.update(new Uint8Array(await blob.arrayBuffer()))
+		.digest("hex");
+	const key = `${repo}/shared-slices/${sliceId}/${variationId}/${digest}${extension}`;
+
+	const formData = new FormData();
+	for (const [field, value] of Object.entries(acl.values.fields)) {
+		formData.append(field, value);
+	}
+	formData.append("key", key);
+	formData.append("Content-Type", type);
+	formData.append("file", blob);
+
+	await request(acl.values.url, { method: "POST", body: formData });
+
+	const url = new URL(key, appendTrailingSlash(acl.imgixEndpoint));
+	url.searchParams.set("auto", "compress,format");
+
+	return url;
+}
+
+export class UnsupportedFileTypeError extends Error {
+	name = "UnsupportedFileTypeError";
+
+	constructor(mimeType: string) {
+		const supportedTypes = Object.keys(SUPPORTED_IMAGE_MIME_TYPES);
+		super(
+			`Unsupported file type: ${mimeType || "unknown"}. Supported: ${supportedTypes.join(", ")}`,
+		);
+	}
+}
+
 function getCustomTypesServiceUrl(host: string): URL {
 	return new URL(`https://customtypes.${host}/`);
 }
+
+function getAclProviderUrl(host: string): URL {
+	return new URL(`https://acl-provider.${host}/`);
+}

src/commands/field-add-boolean.ts

@@ -0,0 +1,55 @@
+import type { BooleanField } from "@prismicio/types-internal/lib/customtypes";
+
+import { capitalCase } from "change-case";
+
+import { getHost, getToken } from "../auth";
+import { CommandError, createCommand, type CommandConfig } from "../lib/command";
+import { resolveFieldTarget, resolveModel, TARGET_OPTIONS } from "../models";
+import { getRepositoryName } from "../project";
+
+const config = {
+	name: "prismic field add boolean",
+	description: "Add a boolean field to a slice or custom type.",
+	positionals: {
+		id: { description: "Field ID", required: true },
+	},
+	options: {
+		...TARGET_OPTIONS,
+		label: { type: "string", description: "Field label" },
+		"default-value": { type: "boolean", description: "Default value" },
+		"true-label": { type: "string", description: "Label for true value" },
+		"false-label": { type: "string", description: "Label for false value" },
+	},
+} satisfies CommandConfig;
+
+export default createCommand(config, async ({ positionals, values }) => {
+	const [id] = positionals;
+	const {
+		label,
+		"default-value": default_value,
+		"true-label": placeholder_true,
+		"false-label": placeholder_false,
+		repo = await getRepositoryName(),
+	} = values;
+
+	const token = await getToken();
+	const host = await getHost();
+	const [fields, saveModel] = await resolveModel(values, { repo, token, host });
+	const [targetFields, fieldId] = resolveFieldTarget(fields, id);
+
+	const field: BooleanField = {
+		type: "Boolean",
+		config: {
+			label: label ?? capitalCase(fieldId),
+			default_value,
+			placeholder_true,
+			placeholder_false,
+		},
+	};
+
+	if (fieldId in targetFields) throw new CommandError(`Field "${id}" already exists.`);
+	targetFields[fieldId] = field;
+	await saveModel();
+
+	console.info(`Field added: ${id}`);
+});