@slicemachine/manager 0.1.1-dev-plugins.3

package/src/managers/customTypes/CustomTypesManager.ts

@@ -0,0 +1,303 @@
+import * as t from "io-ts";
+import fetch from "node-fetch";
+import * as prismicCustomTypesClient from "@prismicio/custom-types-client";
+import { CustomTypes } from "@prismicio/types-internal";
+import {
+	CallHookReturnType,
+	CustomTypeCreateHook,
+	CustomTypeCreateHookData,
+	CustomTypeDeleteHook,
+	CustomTypeDeleteHookData,
+	CustomTypeReadHookData,
+	CustomTypeRenameHook,
+	CustomTypeRenameHookData,
+	CustomTypeUpdateHook,
+	CustomTypeUpdateHookData,
+	HookError,
+} from "@slicemachine/plugin-kit";
+
+import { DecodeError } from "../../lib/DecodeError";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { decodeHookResult } from "../../lib/decodeHookResult";
+
+import { API_ENDPOINTS } from "../../constants/API_ENDPOINTS";
+import { OnlyHookErrors } from "../../types";
+
+import { BaseManager } from "../BaseManager";
+import { UnauthorizedError } from "../../errors";
+
+type SliceMachineManagerReadCustomTypeLibraryReturnType = {
+	ids: string[];
+	errors: (DecodeError | HookError)[];
+};
+
+type SliceMachineManagerReadAllCustomTypeReturnType = {
+	models: { model: CustomTypes.CustomType }[];
+	errors: (DecodeError | HookError)[];
+};
+
+type SliceMachineManagerReadCustomTypeReturnType = {
+	model: CustomTypes.CustomType | undefined;
+	errors: (DecodeError | HookError)[];
+};
+
+type SliceMachineManagerPushCustomTypeArgs = {
+	id: string;
+};
+
+type SliceMachineManagerReadCustomTypeMocksConfigArgs = {
+	customTypeID: string;
+};
+
+type SliceMachineManagerReadCustomTypeMocksConfigArgsReturnType = {
+	// TODO
+	mocksConfig?: Record<string, unknown>;
+	errors: HookError[];
+};
+
+type SliceMachineManagerUpdateCustomTypeMocksConfigArgs = {
+	customTypeID: string;
+	// TODO
+	mocksConfig: Record<string, unknown>;
+};
+
+type SliceMachineManagerUpdateCustomTypeMocksConfigArgsReturnType = {
+	errors: HookError[];
+};
+
+export class CustomTypesManager extends BaseManager {
+	async readCustomTypeLibrary(): Promise<SliceMachineManagerReadCustomTypeLibraryReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type-library:read",
+			undefined,
+		);
+		const { data, errors } = decodeHookResult(
+			t.type({
+				ids: t.array(t.string),
+			}),
+			hookResult,
+		);
+
+		return {
+			ids: data[0]?.ids || [],
+			errors,
+		};
+	}
+
+	async readAllCustomTypes(): Promise<SliceMachineManagerReadAllCustomTypeReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const res: SliceMachineManagerReadAllCustomTypeReturnType = {
+			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) {
+					res.models.push({ model });
+				}
+			}
+		}
+
+		return res;
+	}
+
+	async createCustomType(
+		args: CustomTypeCreateHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeCreateHook>>> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:create",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async readCustomType(
+		args: CustomTypeReadHookData,
+	): Promise<SliceMachineManagerReadCustomTypeReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:read",
+			args,
+		);
+		const { data, errors } = decodeHookResult(
+			t.type({
+				model: CustomTypes.CustomType,
+			}),
+			hookResult,
+		);
+
+		return {
+			model: data[0]?.model,
+			errors,
+		};
+	}
+
+	async updateCustomType(
+		args: CustomTypeUpdateHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeUpdateHook>>> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:update",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async renameCustomType(
+		args: CustomTypeRenameHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeRenameHook>>> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:rename",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	// TODO: Disallow until Custom Types can be deleted.
+	async deleteCustomType(
+		args: CustomTypeDeleteHookData,
+	): Promise<OnlyHookErrors<CallHookReturnType<CustomTypeDeleteHook>>> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:delete",
+			args,
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async pushCustomType(
+		args: SliceMachineManagerPushCustomTypeArgs,
+	): Promise<void> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const authenticationToken = await this.user.getAuthenticationToken();
+		const sliceMachineConfig = await this.project.getSliceMachineConfig();
+
+		// TODO: Handle errors
+		const { model } = await this.readCustomType({ id: args.id });
+
+		if (model) {
+			// TODO: Create a single shared client.
+			const client = prismicCustomTypesClient.createClient({
+				endpoint: API_ENDPOINTS.PrismicModels,
+				repositoryName: sliceMachineConfig.repositoryName,
+				token: authenticationToken,
+				fetch,
+			});
+
+			try {
+				// Check if Custom Type already exists on the repository.
+				await client.getCustomTypeByID(args.id);
+
+				// If it exists on the repository, update it.
+				await client.updateCustomType(model);
+			} catch (error) {
+				if (error instanceof prismicCustomTypesClient.NotFoundError) {
+					// If it doesn't exist on the repository, insert it.
+					await client.insertCustomType(model);
+				} else if (error instanceof prismicCustomTypesClient.ForbiddenError) {
+					throw new UnauthorizedError(
+						"You do not have access to push Custom Types to this Prismic repository.",
+					);
+				} else {
+					throw error;
+				}
+			}
+		}
+	}
+
+	// TODO: Remove
+	async readCustomTypeMocksConfig(
+		args: SliceMachineManagerReadCustomTypeMocksConfigArgs,
+	): Promise<SliceMachineManagerReadCustomTypeMocksConfigArgsReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:asset:read",
+			{
+				customTypeID: args.customTypeID,
+				assetID: "mocks.config.json",
+			},
+		);
+		const data = hookResult.data[0]?.data;
+
+		// TODO: Validate the returned data.
+
+		if (data) {
+			return {
+				mocksConfig: JSON.parse(data.toString()),
+				errors: hookResult.errors,
+			};
+		} else {
+			return {
+				mocksConfig: undefined,
+				errors: hookResult.errors,
+			};
+		}
+	}
+
+	// TODO: Remove
+	async updateCustomTypeMocksConfig(
+		args: SliceMachineManagerUpdateCustomTypeMocksConfigArgs,
+	): Promise<SliceMachineManagerUpdateCustomTypeMocksConfigArgsReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"custom-type:asset:update",
+			{
+				customTypeID: args.customTypeID,
+				asset: {
+					id: "mocks.config.json",
+					data: Buffer.from(JSON.stringify(args.mocksConfig, null, "\t")),
+				},
+			},
+		);
+
+		return {
+			errors: hookResult.errors,
+		};
+	}
+
+	async fetchRemoteCustomTypes(): Promise<CustomTypes.CustomType[]> {
+		const authenticationToken = await this.user.getAuthenticationToken();
+		const sliceMachineConfig = await this.project.getSliceMachineConfig();
+
+		const client = prismicCustomTypesClient.createClient({
+			endpoint: API_ENDPOINTS.PrismicModels,
+			repositoryName: sliceMachineConfig.repositoryName,
+			token: authenticationToken,
+			fetch,
+		});
+
+		return await client.getAllCustomTypes();
+	}
+}

package/src/managers/plugins/PluginsManager.ts

@@ -0,0 +1,48 @@
+import {
+	createSliceMachinePluginRunner,
+	SliceMachinePlugin,
+	SliceMachinePluginRunner,
+} from "@slicemachine/plugin-kit";
+
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+
+import { BaseManager } from "../BaseManager";
+import { SliceMachineManager } from "../SliceMachineManager";
+
+type PluginsManagerConfig = {
+	nativePlugins?: Record<string, SliceMachinePlugin>;
+};
+
+export class PluginsManager extends BaseManager {
+	private _nativePlugins: Record<string, SliceMachinePlugin>;
+
+	constructor(
+		sliceMachineManager: SliceMachineManager,
+		config: PluginsManagerConfig,
+	) {
+		super(sliceMachineManager);
+
+		this._nativePlugins = config.nativePlugins ?? {};
+	}
+
+	async initPlugins(): Promise<void> {
+		const projectRoot = await this.project.getRoot();
+		const sliceMachineConfig = await this.project.getSliceMachineConfig();
+
+		this.sliceMachinePluginRunner = createSliceMachinePluginRunner({
+			project: {
+				root: projectRoot,
+				config: sliceMachineConfig,
+			},
+			nativePlugins: this._nativePlugins,
+		});
+
+		await this.sliceMachinePluginRunner.init();
+	}
+
+	dangerouslyCallHook: SliceMachinePluginRunner["callHook"] = (...args) => {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		return this.sliceMachinePluginRunner.callHook(...args);
+	};
+}

package/src/managers/prismicRepository/PrismicRepositoryManager.ts

@@ -0,0 +1,266 @@
+import * as t from "io-ts";
+import fetch, { Response } from "node-fetch";
+
+import { decode } from "../../lib/decode";
+import { serializeCookies } from "../../lib/serializeCookies";
+
+import { SLICE_MACHINE_USER_AGENT } from "../../constants/SLICE_MACHINE_USER_AGENT";
+import { API_ENDPOINTS } from "../../constants/API_ENDPOINTS";
+
+import { BaseManager } from "../BaseManager";
+
+import {
+	PrismicRepository,
+	PrismicRepositoryRole,
+	PrismicRepositoryUserAgent,
+	PrismicRepositoryUserAgents,
+} from "./types";
+
+const DEFAULT_REPOSITORY_SETTINGS = {
+	plan: "personal",
+	isAnnual: "false",
+	role: "developer",
+};
+
+type PrismicRepositoryManagerCheckExistsArgs = {
+	domain: string;
+};
+
+type PrismicRepositoryManagerCreateArgs = {
+	domain: string;
+	framework: string; // TODO: Type(?)
+};
+
+type PrismicRepositoryManagerDeleteArgs = {
+	domain: string;
+	password: string;
+};
+
+type PrismicRepositoryManagerPushDocumentsArgs = {
+	domain: string;
+	signature: string;
+	documents: Record<string, unknown>; // TODO: Type unknown if possible(?)
+};
+
+export class PrismicRepositoryManager extends BaseManager {
+	// TODO: Add methods for repository-specific actions. E.g. creating a
+	// new repository.
+
+	async readAll(): Promise<PrismicRepository[]> {
+		const url = new URL("./repositories", API_ENDPOINTS.PrismicUser);
+		const res = await this._fetch({ url });
+		const json = await res.json();
+
+		if (res.ok) {
+			const { value: repositories, error } = decode(
+				t.array(PrismicRepository),
+				json,
+			);
+
+			if (error) {
+				throw new Error(
+					`Failed to decode repositories: ${error.errors.join(", ")}`,
+				);
+			}
+
+			return repositories;
+		} else {
+			throw new Error(`Failed to read repositories`, { cause: json });
+		}
+	}
+
+	// Should this be in manager? It's one of the few sync method
+	//
+	// Reply from Angelo 2022-12-22: I think it should be in manager
+	// because we shouldn't be exporting root-level utilities from this
+	// package. If we want to make it more inline with the other methods,
+	// we could simplify the API by changing its signature to the
+	// following:
+	//
+	// ```ts
+	// (repositoryName: string) => Promise<boolean>
+	// ```
+	//
+	// This method would:
+	//
+	// 1. Fetch the list of repositories for the user using `readAll()`.
+	//    The list would be cached.
+	// 2. Determine if the user has write access to the given repository.
+	//
+	// This version has the following benefits:
+	//
+	// - Does not expect the consumer to supply a repository object; it
+	//   only requires a repository name, which could be sourced from
+	//   anything (incl. the project's `sm.json`).
+	//
+	// - Similarly, it does not expect the consumer to call `readAll()`
+	//   before calling this method.
+	//
+	// - Works for repositories that the user does not have access to. For
+	//   example, I could use it to check if I have access to "qwerty",
+	//   even if I am not added as a user. The purpose of the method is
+	//   still valid: do I have write access to a given repository?
+	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 });
+		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 },
+			);
+		}
+	}
+
+	async create(args: PrismicRepositoryManagerCreateArgs): Promise<void> {
+		const url = new URL(
+			"./authentication/newrepository?app=slicemachine",
+			API_ENDPOINTS.PrismicWroom,
+		);
+
+		const body = {
+			...DEFAULT_REPOSITORY_SETTINGS,
+			domain: args.domain,
+			framework: args.framework, // This property appears to be optional for the API
+		};
+
+		const res = await this._fetch({
+			url,
+			method: "POST",
+			body,
+			userAgent: PrismicRepositoryUserAgent.SliceMachine, // Custom User Agent is required
+		});
+		const text = await res.text();
+
+		// Endpoint returns repository name on success, which must be more than 4 characters and less than 30
+		// if (!res.ok) {
+		if (!res.ok || text.length < 4 || text.length > 30) {
+			throw new Error(`Failed to create repository \`${args.domain}\``, {
+				cause: res,
+			});
+		}
+	}
+
+	// TODO: Delete this endpoint? It doesn't seem to be used (I might be wrong). - Angelo
+	async delete(args: PrismicRepositoryManagerDeleteArgs): Promise<void> {
+		const cookies = await this.user.getAuthenticationCookies();
+
+		const url = new URL(
+			`./app/settings/delete?_=${cookies["X_XSRF"]}`, // TODO: Maybe we want to throw early if the token is no available, or get the token another way
+			API_ENDPOINTS.PrismicWroom,
+		);
+		// Update hostname to include repository domain
+		url.hostname = `${args.domain}.${url.hostname}`;
+
+		const body = {
+			confirm: args.domain,
+			password: args.password,
+		};
+
+		const res = await this._fetch({
+			url,
+			method: "POST",
+			body,
+			userAgent: PrismicRepositoryUserAgent.LegacyZero, // Custom User Agent is required
+		});
+
+		if (!res.ok) {
+			throw new Error(`Failed to delete repository \`${args.domain}\``, {
+				cause: res,
+			});
+		}
+	}
+
+	async pushDocuments(
+		args: PrismicRepositoryManagerPushDocumentsArgs,
+	): Promise<void> {
+		const url = new URL("./starter/documents", API_ENDPOINTS.PrismicWroom);
+		// Update hostname to include repository domain
+		url.hostname = `${args.domain}.${url.hostname}`;
+
+		const body = {
+			signature: args.signature,
+			documents: JSON.stringify(args.documents),
+		};
+
+		const res = await this._fetch({
+			url,
+			method: "POST",
+			body,
+			userAgent: PrismicRepositoryUserAgent.LegacyZero, // Custom User Agent is required
+		});
+
+		if (!res.ok) {
+			let reason: string | null = null;
+			try {
+				reason = await res.text();
+			} catch {
+				// Noop
+			}
+
+			// Ideally the API should throw a 409 or something like that...
+			if (reason === "Repository should not contain documents") {
+				throw new Error(
+					`Failed to push documents to repository \`${args.domain}\`, repository is not empty`,
+					{
+						cause: res,
+					},
+				);
+			}
+
+			throw new Error(
+				`Failed to push documents to repository \`${args.domain}\`, ${res.status} ${res.statusText}`,
+				{
+					cause: res,
+				},
+			);
+		}
+	}
+
+	private async _fetch(args: {
+		url: URL;
+		method?: "GET" | "POST";
+		body?: unknown;
+		userAgent?: PrismicRepositoryUserAgents;
+	}): Promise<Response> {
+		const cookies = await this.user.getAuthenticationCookies();
+
+		const extraHeaders: Record<string, string> = {};
+
+		if (args.body) {
+			extraHeaders["Content-Type"] = "application/json";
+		}
+
+		return await fetch(args.url.toString(), {
+			method: args.method,
+			body: args.body ? JSON.stringify(args.body) : undefined,
+			headers: {
+				// Some endpoints rely on the authorization header...
+				Authorization: `Bearer ${cookies["prismic-auth"]}`,
+				Cookie: serializeCookies(cookies),
+				"User-Agent": args.userAgent || SLICE_MACHINE_USER_AGENT,
+				...extraHeaders,
+			},
+		});
+	}
+}

package/src/managers/prismicRepository/types.ts

@@ -0,0 +1,30 @@
+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>;