@slicemachine/manager 0.0.0-alpha.dev-new-release-process.1

package/src/managers/prismicRepository/types.ts

@@ -0,0 +1,169 @@
+import {
+	CustomType,
+	SharedSlice,
+} from "@prismicio/types-internal/lib/customtypes";
+import * as t from "io-ts";
+
+export const PrismicRepositoryUserAgent = {
+	SliceMachine: "prismic-cli/sm",
+	LegacyZero: "prismic-cli/0",
+} as const;
+export type PrismicRepositoryUserAgents =
+	(typeof PrismicRepositoryUserAgent)[keyof typeof PrismicRepositoryUserAgent];
+
+export const PrismicRepositoryRole = {
+	SuperUser: "SuperUser",
+	Administrator: "Administrator",
+	Owner: "Owner",
+	Manager: "Manager",
+	Publisher: "Publisher",
+	Writer: "Writer",
+	Readonly: "Readonly",
+} as const;
+export type PrismicRepositoryRoles =
+	(typeof PrismicRepositoryRole)[keyof typeof PrismicRepositoryRole];
+
+export const PrismicRepository = t.type({
+	domain: t.string,
+	name: t.string,
+	role: t.union([
+		t.keyof(PrismicRepositoryRole),
+		t.record(t.string, t.keyof(PrismicRepositoryRole)),
+	]),
+});
+export type PrismicRepository = t.TypeOf<typeof PrismicRepository>;
+
+export enum ChangeTypes {
+	SLICE_INSERT = "SLICE_INSERT",
+	SLICE_UPDATE = "SLICE_UPDATE",
+	SLICE_DELETE = "SLICE_DELETE",
+	CUSTOM_TYPE_INSERT = "CUSTOM_TYPE_INSERT",
+	CUSTOM_TYPE_UPDATE = "CUSTOM_TYPE_UPDATE",
+	CUSTOM_TYPE_DELETE = "CUSTOM_TYPE_DELETE",
+}
+interface Change {
+	type: ChangeTypes;
+	id: string;
+	payload: Record<string, unknown>;
+}
+interface DeleteChange extends Change {
+	payload: {
+		id: Change["id"];
+	};
+}
+export interface SliceInsertChange extends Change {
+	type: ChangeTypes.SLICE_INSERT;
+	payload: SharedSlice;
+}
+export interface SliceUpdateChange extends Change {
+	type: ChangeTypes.SLICE_UPDATE;
+	payload: SharedSlice;
+}
+export interface SliceDeleteChange extends DeleteChange {
+	type: ChangeTypes.SLICE_DELETE;
+}
+export interface CustomTypeInsertChange extends Change {
+	type: ChangeTypes.CUSTOM_TYPE_INSERT;
+	payload: CustomType;
+}
+export interface CustomTypeUpdateChange extends Change {
+	type: ChangeTypes.CUSTOM_TYPE_UPDATE;
+	payload: CustomType;
+}
+export interface CustomTypeDeleteChange extends DeleteChange {
+	type: ChangeTypes.CUSTOM_TYPE_DELETE;
+}
+export type AllChangeTypes =
+	| SliceInsertChange
+	| SliceUpdateChange
+	| SliceDeleteChange
+	| CustomTypeInsertChange
+	| CustomTypeUpdateChange
+	| CustomTypeDeleteChange;
+export interface BulkBody extends Record<string, unknown> {
+	confirmDeleteDocuments: boolean;
+	changes: AllChangeTypes[];
+}
+
+export const RawLimit = t.type({
+	details: t.type({
+		customTypes: t.array(
+			t.type({
+				id: t.string,
+				numberOfDocuments: t.number,
+				url: t.string,
+			}),
+		),
+	}),
+});
+export type RawLimit = t.TypeOf<typeof RawLimit>;
+export enum LimitType {
+	SOFT = "SOFT",
+	HARD = "HARD",
+}
+export type Limit = RawLimit & {
+	type: LimitType;
+};
+
+export interface ClientError {
+	status: number;
+	message: string;
+}
+
+type ChangeStatus = "NEW" | "MODIFIED" | "DELETED";
+
+type CustomTypeChange = {
+	id: string;
+	type: "CustomType";
+	status: ChangeStatus;
+};
+
+type SliceChange = {
+	id: string;
+	type: "Slice";
+	status: ChangeStatus;
+	libraryID: string;
+};
+
+export type TransactionalMergeArgs = {
+	confirmDeleteDocuments: boolean;
+	changes: (CustomTypeChange | SliceChange)[];
+};
+
+export type TransactionalMergeReturnType = Limit | null;
+
+/**
+ * Framework id sent to Segment from wroom. Property used for the "framework"
+ * and "hasSlicemachine" properties.
+ *
+ * Values from:
+ * https://github.com/prismicio/wroom/blob/65d4f53fd46df7d366d80e7ba9c965339ac7369d/subprojects/common/app/models/Framework.scala#LL20C6-L20C6
+ */
+export type FrameworkWroomTelemetryID = "next" | "nuxt" | "sveltekit" | "other";
+
+/**
+ * Starter id sent to Segment from wroom.Property used for the "starter"
+ * properties.
+ *
+ * Values from:
+ * https://github.com/prismicio/wroom/blob/65d4f53fd46df7d366d80e7ba9c965339ac7369d/conf/application.conf#L938
+ */
+export type StarterId =
+	| "next_multi_page"
+	| "next_blog"
+	| "next_multi_lang"
+	| "nuxt_multi_page"
+	| "nuxt_blog"
+	| "nuxt_multi_lang";
+
+export const Environment = t.type({
+	kind: t.union([t.literal("prod"), t.literal("stage"), t.literal("dev")]),
+	name: t.string,
+	domain: t.string,
+	users: t.array(
+		t.type({
+			id: t.string,
+		}),
+	),
+});
+export type Environment = t.TypeOf<typeof Environment>;

package/src/managers/project/ProjectManager.ts

@@ -0,0 +1,443 @@
+import * as fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+import { detect as niDetect } from "@antfu/ni";
+import { ExecaChildProcess } from "execa";
+import {
+	HookError,
+	CallHookReturnType,
+	ProjectEnvironmentUpdateHook,
+} from "@slicemachine/plugin-kit";
+import * as t from "io-ts";
+
+import { DecodeError } from "../../lib/DecodeError";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { decodeHookResult } from "../../lib/decodeHookResult";
+import { decodeSliceMachineConfig } from "../../lib/decodeSliceMachineConfig";
+import { format } from "../../lib/format";
+import { installDependencies } from "../../lib/installDependencies";
+import { locateFileUpward } from "../../lib/locateFileUpward";
+
+import {
+	PackageManager,
+	SliceMachineConfig,
+	OnlyHookErrors,
+} from "../../types";
+
+import { SliceMachineError, InternalError, PluginError } from "../../errors";
+
+import { SLICE_MACHINE_CONFIG_FILENAME } from "../../constants/SLICE_MACHINE_CONFIG_FILENAME";
+import { TS_CONFIG_FILENAME } from "../../constants/TS_CONFIG_FILENAME";
+import { SLICE_MACHINE_NPM_PACKAGE_NAME } from "../../constants/SLICE_MACHINE_NPM_PACKAGE_NAME";
+
+import { BaseManager } from "../BaseManager";
+
+type ProjectManagerGetSliceMachineConfigPathArgs = {
+	ignoreCache?: boolean;
+};
+
+type ProjectManagerGetRootArgs = {
+	ignoreCache?: boolean;
+};
+
+type ProjectManagerCheckIsTypeScriptArgs = {
+	rootOverride?: string;
+};
+
+type ProjectManagerWriteSliceMachineConfigArgs = {
+	config: SliceMachineConfig;
+	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: ExecaChildProcess;
+};
+
+type ProjectManagerReadEnvironmentReturnType = {
+	environment: string | undefined;
+	errors: (DecodeError | HookError)[];
+};
+
+type ProjectManagerUpdateEnvironmentArgs = {
+	environment: string | undefined;
+};
+
+export class ProjectManager extends BaseManager {
+	private _cachedRoot: string | undefined;
+	private _cachedSliceMachineConfigPath: string | undefined;
+	private _cachedSliceMachineConfig: SliceMachineConfig | undefined;
+
+	async getSliceMachineConfigPath(
+		args?: ProjectManagerGetSliceMachineConfigPathArgs,
+	): Promise<string> {
+		if (this._cachedSliceMachineConfigPath && !args?.ignoreCache) {
+			return this._cachedSliceMachineConfigPath;
+		}
+
+		try {
+			this._cachedSliceMachineConfigPath = await locateFileUpward(
+				SLICE_MACHINE_CONFIG_FILENAME,
+				{ startDir: this.cwd },
+			);
+		} catch (error) {
+			throw new Error(
+				`Could not find a ${SLICE_MACHINE_CONFIG_FILENAME} file. Please create a config file at the root of your project.`,
+			);
+		}
+
+		return this._cachedSliceMachineConfigPath;
+	}
+
+	async getRoot(args?: ProjectManagerGetRootArgs): Promise<string> {
+		if (this._cachedRoot && !args?.ignoreCache) {
+			return this._cachedRoot;
+		}
+
+		const sliceMachineConfigFilePath = await this.getSliceMachineConfigPath({
+			ignoreCache: args?.ignoreCache,
+		});
+
+		this._cachedRoot = path.dirname(sliceMachineConfigFilePath);
+
+		return this._cachedRoot;
+	}
+
+	async suggestRoot(): Promise<string> {
+		const suggestedRootPackageJSON = await locateFileUpward("package.json", {
+			startDir: this.cwd,
+		});
+
+		return path.dirname(suggestedRootPackageJSON);
+	}
+
+	async suggestSliceMachineConfigPath(): Promise<string> {
+		const suggestedRoot = await this.suggestRoot();
+
+		return path.resolve(suggestedRoot, SLICE_MACHINE_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 getSliceMachineConfig(): Promise<SliceMachineConfig> {
+		if (this._cachedSliceMachineConfig) {
+			return this._cachedSliceMachineConfig;
+		} else {
+			return await this.loadSliceMachineConfig();
+		}
+	}
+
+	async writeSliceMachineConfig(
+		args: ProjectManagerWriteSliceMachineConfigArgs,
+	): Promise<void> {
+		const configFilePath =
+			args.path || (await this.getSliceMachineConfigPath());
+
+		const config = await format(
+			JSON.stringify(args.config, null, 2),
+			configFilePath,
+		);
+
+		await fs.writeFile(configFilePath, config, "utf-8");
+		delete this._cachedSliceMachineConfig; // Clear config cache
+	}
+
+	async loadSliceMachineConfig(): Promise<SliceMachineConfig> {
+		// TODO: Reload plugins with a fresh plugin runner. Plugins may
+		// have been added or removed.
+		const configFilePath = await this.getSliceMachineConfigPath();
+
+		let rawConfig: unknown | undefined;
+		try {
+			const contents = await fs.readFile(configFilePath, "utf8");
+			rawConfig = JSON.parse(contents);
+		} catch (error) {
+			if (error instanceof SyntaxError) {
+				throw new SliceMachineError(
+					`Could not parse config file at ${configFilePath}.\n\nError Message: ${error.message}`,
+				);
+			}
+
+			// Noop, more specific error is thrown after
+		}
+
+		if (!rawConfig) {
+			// TODO: Write a more friendly and useful message.
+			throw new Error("No config found.");
+		}
+
+		const { value: sliceMachineConfig, error } =
+			decodeSliceMachineConfig(rawConfig);
+
+		if (error) {
+			// TODO: Write a more friendly and useful message.
+			throw new Error(`Invalid config. ${error.errors.join(", ")}`, {
+				cause: { rawConfig },
+			});
+		}
+
+		// Allow cached config reading using `SliceMachineManager.prototype.getProjectConfig()`.
+		this._cachedSliceMachineConfig = sliceMachineConfig;
+
+		return sliceMachineConfig;
+	}
+
+	async locateSliceMachineUIDir(): Promise<string> {
+		const projectRoot = await this.getRoot();
+
+		const require = createRequire(path.join(projectRoot, "index.js"));
+		const sliceMachinePackageJSONPath = require.resolve(
+			`${SLICE_MACHINE_NPM_PACKAGE_NAME}/package.json`,
+		);
+
+		return path.dirname(sliceMachinePackageJSONPath);
+	}
+
+	/**
+	 * Returns the project's repository name (i.e. the production environment). It
+	 * ignores the currently selected environment.
+	 *
+	 * Use this method to retrieve the production environment domain.
+	 *
+	 * @returns The project's repository name.
+	 */
+	async getRepositoryName(): Promise<string> {
+		const sliceMachineConfig = await this.getSliceMachineConfig();
+
+		return sliceMachineConfig.repositoryName;
+	}
+
+	/**
+	 * Returns the currently selected environment domain if set. If an environment
+	 * is not set, it returns the project's repository name (the production
+	 * environment).
+	 *
+	 * Use this method to retrieve the repository name to be sent with Prismic API
+	 * requests.
+	 *
+	 * @returns The resolved repository name.
+	 */
+	async getResolvedRepositoryName(): Promise<string> {
+		const repositoryName = await this.getRepositoryName();
+
+		const supportsEnvironments = this.project.checkSupportsEnvironments();
+		if (!supportsEnvironments) {
+			return repositoryName;
+		}
+
+		const { environment } = await this.project.readEnvironment();
+
+		return environment ?? repositoryName;
+	}
+
+	async getAdapterName(): Promise<string> {
+		const sliceMachineConfig = await this.getSliceMachineConfig();
+		const adapterName =
+			typeof sliceMachineConfig.adapter === "string"
+				? sliceMachineConfig.adapter
+				: sliceMachineConfig.adapter.resolve;
+
+		return adapterName;
+	}
+
+	async locateAdapterDir(): Promise<string> {
+		const projectRoot = await this.getRoot();
+		const adapterName = await this.getAdapterName();
+		const require = createRequire(path.join(projectRoot, "index.js"));
+		const adapterPackageJSONPath = require.resolve(
+			`${adapterName}/package.json`,
+		);
+
+		return path.dirname(adapterPackageJSONPath);
+	}
+
+	async initProject(args?: ProjectManagerInitProjectArgs): Promise<void> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		// eslint-disable-next-line no-console
+		const log = args?.log || console.log.bind(this);
+
+		const { errors } = await this.sliceMachinePluginRunner.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) {
+			// TODO: Provide better error message.
+			throw new SliceMachineError(
+				`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;
+		}
+	}
+
+	checkSupportsEnvironments(): boolean {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		return (
+			this.sliceMachinePluginRunner.hooksForType("project:environment:read")
+				.length > 0 &&
+			this.sliceMachinePluginRunner.hooksForType("project:environment:update")
+				.length > 0
+		);
+	}
+
+	async readEnvironment(): Promise<ProjectManagerReadEnvironmentReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		await this._assertAdapterSupportsEnvironments();
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"project:environment:read",
+			undefined,
+		);
+		const { data, errors } = decodeHookResult(
+			t.type({
+				environment: t.union([t.undefined, t.string]),
+			}),
+			hookResult,
+		);
+
+		// An undefined value is equivalent to the production environment.
+		// We cast to undefined.
+		const repositoryName = await this.project.getRepositoryName();
+		const environmentDomain =
+			data[0]?.environment === repositoryName
+				? undefined
+				: data[0]?.environment;
+
+		return {
+			environment: environmentDomain,
+			errors,
+		};
+	}
+
+	async updateEnvironment(
+		args: ProjectManagerUpdateEnvironmentArgs,
+	): Promise<OnlyHookErrors<CallHookReturnType<ProjectEnvironmentUpdateHook>>> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		await this._assertAdapterSupportsEnvironments();
+
+		const repositoryName = await this.project.getRepositoryName();
+		const environment =
+			args.environment === repositoryName ? undefined : args.environment;
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"project:environment:update",
+			{ environment },
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	private async _assertAdapterSupportsEnvironments(): Promise<void> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const supportsEnvironments = this.checkSupportsEnvironments();
+
+		if (!supportsEnvironments) {
+			const adapterName = await this.project.getAdapterName();
+
+			throw new PluginError(
+				`${adapterName} does not support environments. Use an adapter that implements the \`project:environment:read\` and \`project:environment:update\` hooks to use environments.`,
+			);
+		}
+	}
+}