@prismicio/manager 0.0.1

package/src/lib/locateFileUpward.ts

@@ -0,0 +1,53 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import { castArray } from "./castArray";
+
+type LocateFileUpwardConfig = {
+	startDir?: string;
+	stopDir?: string;
+	/**
+	 * @internal
+	 */
+	_originalStartDir?: string;
+};
+
+export const locateFileUpward = async (
+	filePathOrPaths: string | readonly string[],
+	{
+		startDir = process.cwd(),
+		stopDir = path.resolve(startDir, "/"),
+		_originalStartDir,
+	}: LocateFileUpwardConfig = {},
+): Promise<string> => {
+	const originalStartDir = _originalStartDir ?? startDir;
+
+	const filePaths = castArray(filePathOrPaths);
+
+	for (const filePath of filePaths) {
+		const resolvedFilePath = path.resolve(startDir, filePath);
+		try {
+			await fs.access(resolvedFilePath);
+
+			return resolvedFilePath;
+		} catch {
+			continue;
+		}
+	}
+
+	if (startDir === stopDir) {
+		const formattedFilePaths = filePaths
+			.map((filePath) => "`" + filePath + "`")
+			.join(" or ");
+
+		throw new Error(
+			`Could not locate ${formattedFilePaths} between \`${originalStartDir}\` and \`${stopDir}\`.`,
+		);
+	}
+
+	return locateFileUpward(filePathOrPaths, {
+		startDir: path.resolve(startDir, ".."),
+		stopDir,
+		_originalStartDir: originalStartDir,
+	});
+};

package/src/lib/prismicrc.ts

@@ -0,0 +1,41 @@
+import * as path from "node:path";
+
+import * as rc9 from "rc9";
+import * as z from "zod";
+
+import { decode } from "./decode";
+
+const PRISMICRC = ".prismicrc";
+
+const PrismicrcSchema = z.object({
+	telemetry: z.boolean().optional(),
+});
+type Prismicrc = z.infer<typeof PrismicrcSchema>;
+
+export const readRawPrismicrc = (dir?: string): Prismicrc => {
+	const rawPrismicrc = dir
+		? rc9.read({ dir, name: PRISMICRC })
+		: rc9.readUser(PRISMICRC);
+
+	const { value: prismicrc, error } = decode(PrismicrcSchema, rawPrismicrc);
+
+	if (error) {
+		throw new Error(
+			`Failed to parse ${
+				dir ? path.resolve(dir, PRISMICRC) : `~/${PRISMICRC}`
+			}: ${error.errors.join(", ")}`,
+		);
+	}
+
+	return prismicrc;
+};
+
+export const readPrismicrc = (dir: string): Prismicrc => {
+	const userPrismicrc = readRawPrismicrc();
+	const projectPrismicrc = readRawPrismicrc(dir);
+
+	return {
+		...userPrismicrc,
+		...projectPrismicrc,
+	};
+};

package/src/lib/trailingSlash.ts

@@ -0,0 +1,5 @@
+export const addTrailingSlash = (
+	url: string | undefined,
+): string | undefined => {
+	return url?.replace(/\/?$/, "/");
+};

package/src/lib/typesInternalSchemas.ts

@@ -0,0 +1,42 @@
+import TypesInternal from "@prismicio/types-internal/lib/customtypes/index.js";
+import * as z from "zod";
+
+/**
+ * Zod schema wrapper for TypesInternal.CustomType. Uses io-ts validation
+ * internally but exposes a Zod-compatible interface.
+ */
+export const CustomTypeSchema: z.ZodType<TypesInternal.CustomType> = z
+	.unknown()
+	.transform((val, ctx) => {
+		const result = TypesInternal.CustomType.decode(val);
+		if (result._tag === "Right") {
+			return result.right;
+		}
+
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Invalid custom type.",
+		});
+
+		return z.NEVER;
+	});
+
+/**
+ * Zod schema wrapper for TypesInternal.SharedSlice. Uses io-ts validation
+ * internally but exposes a Zod-compatible interface.
+ */
+export const SharedSliceSchema: z.ZodType<TypesInternal.SharedSlice> = z
+	.unknown()
+	.transform((val, ctx) => {
+		const result = TypesInternal.SharedSlice.decode(val);
+		if (result._tag === "Right") {
+			return result.right;
+		}
+
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Invalid shared slice.",
+		});
+
+		return z.NEVER;
+	});

package/src/managers/BaseManager.ts

@@ -0,0 +1,74 @@
+import { PluginSystemRunner } from "@prismicio/plugin-kit";
+
+import { PrismicAuthManager } from "../auth/PrismicAuthManager";
+
+import { PrismicManager } from "./PrismicManager";
+import { CustomTypesManager } from "./customTypes/CustomTypesManager";
+import { PluginsManager } from "./plugins/PluginsManager";
+import { PrismicRepositoryManager } from "./prismicRepository/PrismicRepositoryManager";
+import { ProjectManager } from "./project/ProjectManager";
+import { SlicesManager } from "./slices/SlicesManager";
+import { TelemetryManager } from "./telemetry/TelemetryManager";
+import { UserManager } from "./user/UserManager";
+import { VersionsManager } from "./versions/VersionsManager";
+
+export abstract class BaseManager {
+	private _prismicManager: PrismicManager;
+
+	constructor(prismicManager: PrismicManager) {
+		this._prismicManager = prismicManager;
+	}
+
+	protected get prismicAuthManager(): PrismicAuthManager {
+		return this._prismicManager.getPrismicAuthManager();
+	}
+
+	protected get pluginSystemRunner(): PluginSystemRunner | undefined {
+		return this._prismicManager.getPluginSystemRunner();
+	}
+
+	protected set pluginSystemRunner(
+		pluginSystemRunner: PluginSystemRunner | undefined,
+	) {
+		// @ts-expect-error - _pluginSystemRunner is private. We
+		// are intentially ignoring its privacy to allow Manager
+		// classes to access a shared plugin runner via protected
+		// getters and setters.
+		this._prismicManager._pluginSystemRunner = pluginSystemRunner;
+	}
+
+	protected get cwd(): string {
+		return this._prismicManager.cwd;
+	}
+
+	// Protected instance prevents circular intellisense
+	// e.g. prismicManager.user.user.user
+	protected get user(): UserManager {
+		return this._prismicManager.user;
+	}
+	protected get prismicRepository(): PrismicRepositoryManager {
+		return this._prismicManager.prismicRepository;
+	}
+
+	protected get plugins(): PluginsManager {
+		return this._prismicManager.plugins;
+	}
+
+	protected get project(): ProjectManager {
+		return this._prismicManager.project;
+	}
+	protected get customTypes(): CustomTypesManager {
+		return this._prismicManager.customTypes;
+	}
+	protected get slices(): SlicesManager {
+		return this._prismicManager.slices;
+	}
+
+	protected get versions(): VersionsManager {
+		return this._prismicManager.versions;
+	}
+
+	protected get telemetry(): TelemetryManager {
+		return this._prismicManager.telemetry;
+	}
+}

package/src/managers/PrismicManager.ts

@@ -0,0 +1,81 @@
+import { Plugin, PluginSystemRunner } from "@prismicio/plugin-kit";
+
+import { PrismicAuthManager } from "../auth/PrismicAuthManager";
+import { createPrismicAuthManager } from "../auth/createPrismicAuthManager";
+import { API_ENDPOINTS, APIEndpoints } from "../constants/API_ENDPOINTS";
+
+import { CustomTypesManager } from "./customTypes/CustomTypesManager";
+import { PluginsManager } from "./plugins/PluginsManager";
+import { PrismicRepositoryManager } from "./prismicRepository/PrismicRepositoryManager";
+import { ProjectManager } from "./project/ProjectManager";
+import { SlicesManager } from "./slices/SlicesManager";
+import { TelemetryManager } from "./telemetry/TelemetryManager";
+import { UserManager } from "./user/UserManager";
+import { VersionsManager } from "./versions/VersionsManager";
+
+type PrismicManagerConstructorArgs = {
+	cwd?: string;
+	nativePlugins?: Record<string, Plugin>;
+};
+
+export class PrismicManager {
+	private _pluginSystemRunner: PluginSystemRunner | undefined = undefined;
+	private _prismicAuthManager: PrismicAuthManager;
+
+	cwd: string;
+
+	customTypes: CustomTypesManager;
+	plugins: PluginsManager;
+	prismicRepository: PrismicRepositoryManager;
+	project: ProjectManager;
+	slices: SlicesManager;
+	telemetry: TelemetryManager;
+	user: UserManager;
+	versions: VersionsManager;
+
+	constructor(args?: PrismicManagerConstructorArgs) {
+		// _prismicAuthManager must be set at least before UserManager
+		// is instantiated. It depends on the PrismicAuthManager for
+		// authentication-related methods.
+		this._prismicAuthManager = createPrismicAuthManager();
+
+		this.user = new UserManager(this);
+		this.prismicRepository = new PrismicRepositoryManager(this);
+
+		this.plugins = new PluginsManager(this, {
+			nativePlugins: args?.nativePlugins,
+		});
+
+		this.project = new ProjectManager(this);
+		this.customTypes = new CustomTypesManager(this);
+		this.slices = new SlicesManager(this);
+
+		this.versions = new VersionsManager(this);
+
+		this.telemetry = new TelemetryManager(this);
+
+		this.cwd = args?.cwd ?? process.cwd();
+	}
+
+	// The `_pluginSystemRunner` property is hidden behind a function to
+	// discourage access. Using a function deliberately breaks the pattern
+	// of other child managers that are accessible as properties, like
+	// `project`, `plugins`, etc. We do not treat PluginSystemRunner
+	// as a child manager.
+	getPluginSystemRunner(): PluginSystemRunner | undefined {
+		return this._pluginSystemRunner;
+	}
+
+	// The `_prismicAuthManager` property is hidden behind a function to
+	// discourage access. Using a function deliberately breaks the pattern
+	// of other child managers that are accessible as properties, like
+	// `project`, `plugins`, etc. We do not treat PrismicAuthManager as a
+	// child manager.
+	getPrismicAuthManager(): PrismicAuthManager {
+		return this._prismicAuthManager;
+	}
+
+	getAPIEndpoints(): APIEndpoints {
+		return API_ENDPOINTS;
+	}
+}

package/src/managers/createPrismicManager.ts

@@ -0,0 +1,9 @@
+import { PrismicManager } from "./PrismicManager";
+
+type CreatePrismicManagerArgs = ConstructorParameters<typeof PrismicManager>;
+
+export const createPrismicManager = (
+	...args: CreatePrismicManagerArgs
+): PrismicManager => {
+	return new PrismicManager(...args);
+};

package/src/managers/customTypes/CustomTypesManager.ts

@@ -0,0 +1,221 @@
+import * as prismicCustomTypesClient from "@prismicio/custom-types-client";
+import {
+	CallHookReturnType,
+	CustomTypeCreateHook,
+	CustomTypeCreateHookData,
+	CustomTypeReadHookData,
+	CustomTypeRenameHook,
+	CustomTypeRenameHookData,
+	CustomTypeUpdateHookData,
+	HookError,
+} 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 { CustomTypeSchema } from "../../lib/typesInternalSchemas";
+import { OnlyHookErrors } from "../../types";
+import { BaseManager } from "../BaseManager";
+
+import { type CustomTypeFormat } from "./types";
+
+type PrismicManagerReadCustomTypeLibraryReturnType = {
+	ids: string[];
+	errors: (DecodeError | HookError)[];
+};
+
+type CustomTypesManagerReadAllCustomTypesArgs = {
+	format: CustomTypeFormat;
+};
+
+type PrismicManagerReadAllCustomTypeReturnType = {
+	models: { model: TypesInternal.CustomType }[];
+	errors: (DecodeError | HookError)[];
+};
+
+type PrismicManagerReadCustomTypeReturnType = {
+	model: TypesInternal.CustomType | undefined;
+	errors: (DecodeError | HookError)[];
+};
+
+type PrismicManagerUpdateCustomTypeArgs = CustomTypeUpdateHookData;
+
+type CustomTypesManagerDeleteCustomTypeArgs = {
+	id: string;
+};
+
+type CustomTypesManagerDeleteCustomTypeReturnType = {
+	errors: (DecodeError | HookError)[];
+};
+
+type CustomTypesManagerUpdateCustomTypeReturnType = {
+	errors: (DecodeError | HookError)[];
+};
+
+export class CustomTypesManager extends BaseManager {
+	async readCustomTypeLibrary(): Promise<PrismicManagerReadCustomTypeLibraryReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"custom-type-library:read",
+			undefined,
+		);
+		const { data, errors } = decodeHookResult(
+			z.object({
+				ids: z.array(z.string()),
+			}),
+			hookResult,
+		);
+
+		return {
+			ids: data[0]?.ids || [],
+			errors,
+		};
+	}
+
+	async readAllCustomTypes(
+		args?: CustomTypesManagerReadAllCustomTypesArgs,
+	): Promise<PrismicManagerReadAllCustomTypeReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const res: PrismicManagerReadAllCustomTypeReturnType = {
+			models: [],
+			errors: [],
+		};
+
+		const { ids, errors } = await this.readCustomTypeLibrary();
+		res.errors = [...res.errors, ...errors];
+
+		if (ids) {
+			for (const id of ids) {
+				const { model, errors } = await this.readCustomType({ id });
+				res.errors = [...res.errors, ...errors];
+
+				if (model && (!args || args.format === model.format)) {
+					res.models.push({ model });
+				}
+			}
+		}
+
+		return res;
+	}
+
+	async createCustomType(
+		args: CustomTypeCreateHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeCreateHook>>> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"custom-type:create",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async readCustomType(
+		args: CustomTypeReadHookData,
+	): Promise<PrismicManagerReadCustomTypeReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"custom-type:read",
+			args,
+		);
+		const { data, errors } = decodeHookResult(
+			z.object({
+				model: CustomTypeSchema,
+			}),
+			hookResult,
+		);
+
+		return {
+			model: data[0]?.model,
+			errors,
+		};
+	}
+
+	async updateCustomType(
+		args: PrismicManagerUpdateCustomTypeArgs,
+	): Promise<CustomTypesManagerUpdateCustomTypeReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+		const { model } = args;
+
+		const customTypeUpdateResult = await this.pluginSystemRunner.callHook(
+			"custom-type:update",
+			{ model },
+		);
+
+		if (customTypeUpdateResult.errors.length > 0) {
+			return { errors: customTypeUpdateResult.errors };
+		}
+
+		return { errors: [] };
+	}
+
+	async renameCustomType(
+		args: CustomTypeRenameHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeRenameHook>>> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const hookResult = await this.pluginSystemRunner.callHook(
+			"custom-type:rename",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async deleteCustomType(
+		args: CustomTypesManagerDeleteCustomTypeArgs,
+	): Promise<CustomTypesManagerDeleteCustomTypeReturnType> {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		const { model, errors: readCustomTypeErrors } = await this.readCustomType({
+			id: args.id,
+		});
+
+		if (model) {
+			const hookResult = await this.pluginSystemRunner.callHook(
+				"custom-type:delete",
+				{ model },
+			);
+
+			return {
+				errors: hookResult.errors,
+			};
+		} else {
+			return {
+				errors: readCustomTypeErrors,
+			};
+		}
+	}
+
+	async fetchRemoteCustomTypes(): Promise<TypesInternal.CustomType[]> {
+		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.getAllCustomTypes();
+	}
+}

package/src/managers/customTypes/types.ts

@@ -0,0 +1,3 @@
+import TypesInternal from "@prismicio/types-internal/lib/customtypes/index.js";
+
+export type CustomTypeFormat = NonNullable<TypesInternal.CustomType["format"]>;

package/src/managers/plugins/PluginsManager.ts

@@ -0,0 +1,44 @@
+import {
+	createPluginSystemRunner,
+	Plugin,
+	PluginSystemRunner,
+} from "@prismicio/plugin-kit";
+
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { BaseManager } from "../BaseManager";
+import { PrismicManager } from "../PrismicManager";
+
+type PluginsManagerConfig = {
+	nativePlugins?: Record<string, Plugin>;
+};
+
+export class PluginsManager extends BaseManager {
+	private _nativePlugins: Record<string, Plugin>;
+
+	constructor(prismicManager: PrismicManager, config: PluginsManagerConfig) {
+		super(prismicManager);
+
+		this._nativePlugins = config.nativePlugins ?? {};
+	}
+
+	async initPlugins(): Promise<void> {
+		const projectRoot = await this.project.getRoot();
+		const prismicConfig = await this.project.getPrismicConfig();
+
+		this.pluginSystemRunner = createPluginSystemRunner({
+			project: {
+				root: projectRoot,
+				config: prismicConfig,
+			},
+			nativePlugins: this._nativePlugins,
+		});
+
+		await this.pluginSystemRunner.init();
+	}
+
+	dangerouslyCallHook: PluginSystemRunner["callHook"] = (...args) => {
+		assertPluginsInitialized(this.pluginSystemRunner);
+
+		return this.pluginSystemRunner.callHook(...args);
+	};
+}

package/src/managers/prismicRepository/PrismicRepositoryManager.ts

@@ -0,0 +1,120 @@
+import fetch, { Response } 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 { decode } from "../../lib/decode";
+import { BaseManager } from "../BaseManager";
+
+import {
+	PrismicRepository,
+	PrismicRepositoryRole,
+	PrismicRepositorySchema,
+} from "./types";
+
+type PrismicRepositoryManagerCheckExistsArgs = {
+	domain: string;
+};
+
+export class PrismicRepositoryManager extends BaseManager {
+	async readAll(): Promise<PrismicRepository[]> {
+		const url = new URL("./repositories", API_ENDPOINTS.PrismicLegacyUserApi);
+		const res = await this._fetch({ url });
+
+		if (res.ok) {
+			const json = await res.json();
+			const { value: repositories, error } = decode(
+				z.array(PrismicRepositorySchema),
+				json,
+			);
+
+			if (error) {
+				throw new Error(
+					`Failed to decode repositories: ${error.errors.join(", ")}`,
+				);
+			}
+
+			return repositories;
+		} else {
+			const text = await res.text();
+			throw new Error(`Failed to read repositories`, { cause: text });
+		}
+	}
+
+	hasWriteAccess(repository: PrismicRepository): boolean {
+		switch (repository.role) {
+			case PrismicRepositoryRole.SuperUser:
+			case PrismicRepositoryRole.Owner:
+			case PrismicRepositoryRole.Administrator:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	async checkExists(
+		args: PrismicRepositoryManagerCheckExistsArgs,
+	): Promise<boolean> {
+		const url = new URL(
+			`./app/dashboard/repositories/${args.domain}/exists`,
+			API_ENDPOINTS.PrismicWroom,
+		);
+		const res = await this._fetch({
+			url,
+			skipAuthentication: true,
+		});
+
+		const text = await res.text();
+
+		if (res.ok) {
+			return text === "false"; // Endpoint returns `false` when repository exists
+		} else {
+			throw new Error(
+				`Failed to check repository existence for domain \`${args.domain}\``,
+				{ cause: text },
+			);
+		}
+	}
+
+	private async _fetch(args: {
+		url: URL;
+		method?: "GET" | "POST" | "PATCH";
+		body?: unknown;
+		repository?: string;
+		skipAuthentication?: boolean;
+	}): Promise<Response> {
+		let token;
+		try {
+			token = await this.user.getAuthenticationToken();
+		} catch (e) {
+			if (!args.skipAuthentication) {
+				throw e;
+			}
+		}
+
+		const extraHeaders: Record<string, string> = {};
+
+		if (args.body) {
+			extraHeaders["Content-Type"] = "application/json";
+		}
+
+		if (args.repository) {
+			extraHeaders.repository = args.repository;
+		}
+
+		return await fetch(args.url.toString(), {
+			method: args.method,
+			body: args.body ? JSON.stringify(args.body) : undefined,
+			headers: {
+				...(token !== undefined
+					? {
+							Authorization: `Bearer ${token}`,
+						}
+					: {}),
+				"User-Agent": PRISMIC_CLI_USER_AGENT,
+				...extraHeaders,
+			},
+		});
+	}
+}