@prismicio/manager 0.0.1

package/src/managers/prismicRepository/types.ts

@@ -0,0 +1,23 @@
+import * as z from "zod";
+
+export enum PrismicRepositoryRole {
+	SuperUser = "SuperUser",
+	Administrator = "Administrator",
+	Owner = "Owner",
+	Manager = "Manager",
+	Publisher = "Publisher",
+	Writer = "Writer",
+	Readonly = "Readonly",
+}
+
+export type PrismicRepositoryRoles = PrismicRepositoryRole;
+
+export const PrismicRepositorySchema = z.object({
+	domain: z.string(),
+	name: z.string(),
+	role: z.union([
+		z.enum(PrismicRepositoryRole),
+		z.record(z.string(), z.enum(PrismicRepositoryRole)),
+	]),
+});
+export type PrismicRepository = z.infer<typeof PrismicRepositorySchema>;

package/src/managers/project/ProjectManager.ts

@@ -0,0 +1,354 @@
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import { detect as niDetect } from "@antfu/ni";
+import { type ResultPromise } from "execa";
+
+import { PRISMIC_CONFIG_FILENAME } from "../../constants/PRISMIC_CONFIG_FILENAME";
+import { SLICEMACHINE_CONFIG_FILENAME } from "../../constants/SLICEMACHINE_CONFIG_FILENAME";
+import { TS_CONFIG_FILENAME } from "../../constants/TS_CONFIG_FILENAME";
+import { PrismicError, InternalError } from "../../errors";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { decodePrismicConfig } from "../../lib/decodePrismicConfig";
+import { format } from "../../lib/format";
+import { installDependencies } from "../../lib/installDependencies";
+import { locateFileUpward } from "../../lib/locateFileUpward";
+import { PackageManager, PrismicConfig } from "../../types";
+import { BaseManager } from "../BaseManager";
+
+type ProjectManagerGetPrismicConfigPathArgs = {
+	ignoreCache?: boolean;
+};
+
+type ProjectManagerGetRootArgs = {
+	ignoreCache?: boolean;
+};
+
+type ProjectManagerCheckIsTypeScriptArgs = {
+	rootOverride?: string;
+};
+
+type ProjectManagerWritePrismicConfigArgs = {
+	config: PrismicConfig;
+	path?: string;
+};
+
+type ProjectManagerInitProjectArgs = {
+	log?: (message: string) => void;
+};
+
+type ProjectManagerDetectPackageManager = {
+	root?: string;
+};
+
+type ProjectManagerInstallDependenciesArgs = {
+	dependencies: Record<string, string>;
+	dev?: boolean;
+	packageManager?: PackageManager;
+	log?: (message: string) => void;
+};
+
+type ProjectManagerInstallDependenciesReturnType = {
+	execaProcess: ResultPromise;
+};
+
+export class ProjectManager extends BaseManager {
+	private _cachedRoot: string | undefined;
+	private _cachedPrismicConfigPath: string | undefined;
+	private _cachedPrismicConfig: PrismicConfig | undefined;
+
+	async getPrismicConfigPath(
+		args?: ProjectManagerGetPrismicConfigPathArgs,
+	): Promise<string> {
+		if (this._cachedPrismicConfigPath && !args?.ignoreCache) {
+			return this._cachedPrismicConfigPath;
+		}
+
+		try {
+			this._cachedPrismicConfigPath = await locateFileUpward(
+				PRISMIC_CONFIG_FILENAME,
+				{ startDir: this.cwd },
+			);
+		} catch {
+			throw new Error(
+				`Could not find a ${PRISMIC_CONFIG_FILENAME} file. Please create a config file at the root of your project.`,
+			);
+		}
+
+		return this._cachedPrismicConfigPath;
+	}
+
+	async getRoot(args?: ProjectManagerGetRootArgs): Promise<string> {
+		if (this._cachedRoot && !args?.ignoreCache) {
+			return this._cachedRoot;
+		}
+
+		const prismicConfigFilePath = await this.getPrismicConfigPath({
+			ignoreCache: args?.ignoreCache,
+		});
+
+		this._cachedRoot = path.dirname(prismicConfigFilePath);
+
+		return this._cachedRoot;
+	}
+
+	async suggestRoot(): Promise<string> {
+		const suggestedRootPackageJSON = await locateFileUpward("package.json", {
+			startDir: this.cwd,
+		});
+
+		return path.dirname(suggestedRootPackageJSON);
+	}
+
+	async suggestPrismicConfigPath(): Promise<string> {
+		const suggestedRoot = await this.suggestRoot();
+
+		return path.resolve(suggestedRoot, PRISMIC_CONFIG_FILENAME);
+	}
+
+	async checkIsTypeScript(
+		args?: ProjectManagerCheckIsTypeScriptArgs,
+	): Promise<boolean> {
+		const root = args?.rootOverride || (await this.getRoot());
+		const rootTSConfigPath = path.resolve(root, TS_CONFIG_FILENAME);
+
+		// We just care if the file exists, we don't need access to it
+		return existsSync(rootTSConfigPath);
+	}
+
+	async getPrismicConfig(): Promise<PrismicConfig> {
+		if (this._cachedPrismicConfig) {
+			return this._cachedPrismicConfig;
+		} else {
+			return await this.loadPrismicConfig();
+		}
+	}
+
+	async writePrismicConfig(
+		args: ProjectManagerWritePrismicConfigArgs,
+	): Promise<void> {
+		const configFilePath = args.path || (await this.getPrismicConfigPath());
+
+		const config = await format(
+			JSON.stringify(args.config, null, 2),
+			configFilePath,
+		);
+
+		await fs.writeFile(configFilePath, config, "utf-8");
+
+		// Clear config cache
+		delete this._cachedPrismicConfig;
+	}
+
+	async loadPrismicConfig(): Promise<PrismicConfig> {
+		const configFilePath = await this.getPrismicConfigPath();
+
+		let rawConfig: unknown | undefined;
+		try {
+			const contents = await fs.readFile(configFilePath, "utf8");
+			rawConfig = JSON.parse(contents);
+		} catch (error) {
+			if (error instanceof SyntaxError) {
+				throw new PrismicError(
+					`Could not parse config file at ${configFilePath}.\n\nError Message: ${error.message}`,
+				);
+			}
+
+			// Noop, more specific error is thrown after
+		}
+
+		if (!rawConfig) {
+			throw new Error(
+				"No Prismic config found, please initialize your project with Prismic first.",
+			);
+		}
+
+		const { value: prismicConfig, error } = decodePrismicConfig(rawConfig);
+
+		if (error) {
+			throw new Error(`Invalid Prismic config. ${error.errors.join(", ")}`, {
+				cause: { rawConfig },
+			});
+		}
+
+		this._cachedPrismicConfig = prismicConfig;
+
+		return prismicConfig;
+	}
+
+	async getRepositoryName(): Promise<string> {
+		const prismicConfig = await this.getPrismicConfig();
+
+		return prismicConfig.repositoryName;
+	}
+
+	async checkLegacyConfigExists(): Promise<boolean> {
+		try {
+			await locateFileUpward(SLICEMACHINE_CONFIG_FILENAME, {
+				startDir: this.cwd,
+			});
+
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	async migrateLegacyConfig(): Promise<void> {
+		const suggestedRoot = await this.suggestRoot();
+		const legacyConfigPath = path.resolve(
+			suggestedRoot,
+			SLICEMACHINE_CONFIG_FILENAME,
+		);
+		const newConfigPath = path.resolve(suggestedRoot, PRISMIC_CONFIG_FILENAME);
+
+		// Check if legacy config exists
+		try {
+			await fs.access(legacyConfigPath);
+		} catch {
+			throw new Error(
+				`Legacy config file ${SLICEMACHINE_CONFIG_FILENAME} not found.`,
+			);
+		}
+
+		// Check if new config already exists
+		try {
+			await fs.access(newConfigPath);
+			throw new Error(
+				`Cannot migrate: ${PRISMIC_CONFIG_FILENAME} already exists.`,
+			);
+		} catch {
+			// File doesn't exist, which is what we want
+		}
+
+		const legacyConfigContent = await fs.readFile(legacyConfigPath, "utf8");
+
+		// Parse and validate the config
+		let rawConfig: unknown;
+		try {
+			rawConfig = JSON.parse(legacyConfigContent);
+		} catch (error) {
+			if (error instanceof SyntaxError) {
+				throw new PrismicError(
+					`Could not parse legacy config file at ${legacyConfigPath}.\n\nError Message: ${error.message}`,
+				);
+			}
+			throw error;
+		}
+
+		const { value: prismicConfig, error } = decodePrismicConfig(rawConfig);
+
+		if (error) {
+			throw new Error(
+				`Invalid legacy Prismic config. ${error.errors.join(", ")}`,
+				{
+					cause: { rawConfig },
+				},
+			);
+		}
+
+		// Format and write the new config
+		const formattedConfig = await format(
+			JSON.stringify(prismicConfig, null, 2),
+			newConfigPath,
+		);
+
+		await fs.writeFile(newConfigPath, formattedConfig, "utf-8");
+
+		// Remove legacy config file
+		await fs.unlink(legacyConfigPath);
+
+		// Clear caches
+		delete this._cachedPrismicConfig;
+		delete this._cachedPrismicConfigPath;
+		delete this._cachedRoot;
+	}
+
+	async initProject(args?: ProjectManagerInitProjectArgs): Promise<void> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		// eslint-disable-next-line no-console
+		const log = args?.log || console.log.bind(this);
+
+		const { errors } = await this.pluginSystemRunner.callHook("project:init", {
+			log,
+			installDependencies: async (args) => {
+				const { execaProcess } = await this.installDependencies({
+					dependencies: args.dependencies,
+					dev: args.dev,
+					log,
+				});
+
+				await execaProcess;
+			},
+		});
+
+		if (errors.length > 0) {
+			throw new PrismicError(
+				`Failed to initialize project: ${errors.join(", ")}`,
+			);
+		}
+	}
+
+	async detectPackageManager(
+		args?: ProjectManagerDetectPackageManager,
+	): Promise<PackageManager> {
+		const projectRoot = args?.root || (await this.getRoot());
+
+		const packageManager = await niDetect({
+			autoInstall: true,
+			cwd: projectRoot,
+		});
+
+		return packageManager || "npm";
+	}
+
+	async installDependencies(
+		args: ProjectManagerInstallDependenciesArgs,
+	): Promise<ProjectManagerInstallDependenciesReturnType> {
+		const packageManager =
+			args.packageManager || (await this.detectPackageManager());
+
+		// eslint-disable-next-line no-console
+		const log = args.log || console.log.bind(this);
+
+		const wrappedLogger = (data: Buffer | string | null) => {
+			if (data instanceof Buffer) {
+				log(data.toString());
+			} else if (typeof data === "string") {
+				log(data);
+			}
+		};
+
+		try {
+			const { execaProcess } = await installDependencies({
+				packageManager,
+				dependencies: args.dependencies,
+				dev: args.dev,
+			});
+
+			// Don't clutter console with logs when process is non TTY (CI, etc.)
+			if (process.stdout.isTTY || process.env.NODE_ENV === "test") {
+				execaProcess.stdout?.on("data", wrappedLogger);
+			}
+			execaProcess.stderr?.on("data", wrappedLogger);
+
+			return {
+				execaProcess,
+			};
+		} catch (error) {
+			if (
+				error instanceof Error &&
+				"shortMessage" in error &&
+				"stderr" in error
+			) {
+				throw new InternalError("Package installation failed", {
+					cause: error,
+				});
+			}
+
+			throw error;
+		}
+	}
+}

package/src/managers/slices/SlicesManager.ts

@@ -0,0 +1,308 @@
+import * as prismicCustomTypesClient from "@prismicio/custom-types-client";
+import {
+	CallHookReturnType,
+	HookError,
+	SliceCreateHook,
+	SliceCreateHookData,
+	SliceLibraryReadHookData,
+	SliceReadHookData,
+	SliceRenameHook,
+	SliceRenameHookData,
+	SliceUpdateHook,
+} from "@prismicio/plugin-kit";
+import TypesInternal from "@prismicio/types-internal/lib/customtypes/index.js";
+import fetch from "node-fetch";
+import * as z from "zod";
+
+import { API_ENDPOINTS } from "../../constants/API_ENDPOINTS";
+import { PRISMIC_CLI_USER_AGENT } from "../../constants/PRISMIC_CLI_USER_AGENT";
+import { DecodeError } from "../../lib/DecodeError";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { decodeHookResult } from "../../lib/decodeHookResult";
+import { SharedSliceSchema } from "../../lib/typesInternalSchemas";
+import { OnlyHookErrors } from "../../types";
+import { BaseManager } from "../BaseManager";
+
+type SlicesManagerReadSliceLibraryReturnType = {
+	sliceIDs: string[];
+	errors: (DecodeError | HookError)[];
+};
+
+type SlicesManagerReadAllSliceLibrariesReturnType = {
+	libraries: {
+		libraryID: string;
+		sliceIDs: string[] | undefined;
+	}[];
+	errors: (DecodeError | HookError)[];
+};
+
+type PrismicManagerReadAllSlicesForLibraryArgs = {
+	libraryID: string;
+};
+
+type PrismicManagerUpdateSliceArgs = {
+	libraryID: string;
+	model: TypesInternal.SharedSlice;
+};
+
+type PrismicManagerReadAllSlicesForLibraryReturnType = {
+	models: { model: TypesInternal.SharedSlice }[];
+	errors: (DecodeError | HookError)[];
+};
+
+type PrismicManagerReadAllSlicesReturnType = {
+	models: {
+		libraryID: string;
+		model: TypesInternal.SharedSlice;
+	}[];
+	errors: (DecodeError | HookError)[];
+};
+
+type PrismicManagerReadSliceReturnType = {
+	model: TypesInternal.SharedSlice | undefined;
+	errors: (DecodeError | HookError)[];
+};
+
+type PrismicManagerDeleteSliceArgs = {
+	libraryID: string;
+	sliceID: string;
+};
+
+type PrismicManagerDeleteSliceReturnType = {
+	errors: (DecodeError | HookError)[];
+};
+
+export class SlicesManager extends BaseManager {
+	async readSliceLibrary(
+		args: SliceLibraryReadHookData,
+	): Promise<SlicesManagerReadSliceLibraryReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"slice-library:read",
+			args,
+		);
+		const { data, errors } = decodeHookResult(
+			z.object({
+				id: z.string(),
+				sliceIDs: z.array(z.string()),
+			}),
+			hookResult,
+		);
+
+		return {
+			sliceIDs: data[0]?.sliceIDs ?? [],
+			errors: errors,
+		};
+	}
+
+	async getDefaultLibraryID(): Promise<string> {
+		const prismicConfig = await this.project.getPrismicConfig();
+		const libraryIDs = prismicConfig.libraries || [];
+
+		return libraryIDs[0];
+	}
+
+	async readAllSliceLibraries(): Promise<SlicesManagerReadAllSliceLibrariesReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const prismicConfig = await this.project.getPrismicConfig();
+		const libraryIDs = prismicConfig.libraries || [];
+
+		const res: SlicesManagerReadAllSliceLibrariesReturnType = {
+			libraries: [],
+			errors: [],
+		};
+
+		for (const libraryID of libraryIDs) {
+			const { sliceIDs, errors } = await this.readSliceLibrary({
+				libraryID,
+			});
+			res.errors = [...res.errors, ...errors];
+
+			res.libraries.push({
+				libraryID,
+				sliceIDs,
+			});
+		}
+
+		return res;
+	}
+
+	async readAllSlicesForLibrary(
+		args: PrismicManagerReadAllSlicesForLibraryArgs,
+	): Promise<PrismicManagerReadAllSlicesForLibraryReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const res: PrismicManagerReadAllSlicesForLibraryReturnType = {
+			models: [],
+			errors: [],
+		};
+
+		const { sliceIDs, errors } = await this.readSliceLibrary({
+			libraryID: args.libraryID,
+		});
+		res.errors.push(...errors);
+
+		if (sliceIDs) {
+			for (const sliceID of sliceIDs) {
+				const { model, errors } = await this.readSlice({
+					libraryID: args.libraryID,
+					sliceID,
+				});
+				res.errors.push(...errors);
+
+				if (model) {
+					res.models.push({ model });
+				}
+			}
+		}
+
+		return res;
+	}
+
+	async readAllSlices(): Promise<PrismicManagerReadAllSlicesReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const prismicConfig = await this.project.getPrismicConfig();
+		const libraryIDs = prismicConfig.libraries || [];
+
+		const res: PrismicManagerReadAllSlicesReturnType = {
+			models: [],
+			errors: [],
+		};
+
+		for (const libraryID of libraryIDs) {
+			const { models, errors } = await this.readAllSlicesForLibrary({
+				libraryID,
+			});
+			res.errors.push(...errors);
+
+			for (const model of models) {
+				res.models.push({
+					libraryID,
+					model: model.model,
+				});
+			}
+		}
+
+		return res;
+	}
+
+	async createSlice(
+		args: SliceCreateHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<SliceCreateHook>>> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"slice:create",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async readSlice(
+		args: SliceReadHookData,
+	): Promise<PrismicManagerReadSliceReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"slice:read",
+			args,
+		);
+		const { data, errors } = decodeHookResult(
+			z.object({
+				model: SharedSliceSchema,
+			}),
+			hookResult,
+		);
+
+		return {
+			model: data[0]?.model,
+			errors: errors.map((error) => {
+				error.message = `Failed to decode slice model with id '${args.sliceID}': ${error.message}`;
+
+				return error;
+			}),
+		};
+	}
+
+	async updateSlice(
+		args: PrismicManagerUpdateSliceArgs,
+	): Promise<OnlyHookErrors<CallHookReturnType<SliceUpdateHook>>> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"slice:update",
+			args,
+		);
+
+		return {
+			errors: [...hookResult.errors],
+		};
+	}
+
+	async renameSlice(
+		args: SliceRenameHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<SliceRenameHook>>> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"slice:rename",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async deleteSlice(
+		args: PrismicManagerDeleteSliceArgs,
+	): Promise<PrismicManagerDeleteSliceReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const { model, errors: readSliceErrors } = await this.readSlice({
+			libraryID: args.libraryID,
+			sliceID: args.sliceID,
+		});
+
+		if (model) {
+			const { errors: deleteSliceErrors } =
+				await this.pluginSystemRunner.callHook("slice:delete", {
+					model,
+					libraryID: args.libraryID,
+				});
+
+			return {
+				errors: deleteSliceErrors,
+			};
+		} else {
+			return {
+				errors: readSliceErrors,
+			};
+		}
+	}
+
+	async fetchRemoteSlices(): Promise<TypesInternal.SharedSlice[]> {
+		const authenticationToken = await this.user.getAuthenticationToken();
+		const repositoryName = await this.project.getRepositoryName();
+
+		const client = prismicCustomTypesClient.createClient({
+			endpoint: API_ENDPOINTS.PrismicLegacyCustomTypesApi,
+			repositoryName,
+			token: authenticationToken,
+			fetch,
+			fetchOptions: {
+				headers: {
+					"User-Agent": PRISMIC_CLI_USER_AGENT,
+				},
+			},
+		});
+
+		return await client.getAllSharedSlices();
+	}
+}