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

package/src/managers/screenshots/ScreenshotsManager.ts

@@ -0,0 +1,199 @@
+import * as t from "io-ts";
+import { fileTypeFromBuffer } from "file-type";
+import pLimit from "p-limit";
+import fetch, { FormData, Blob, Response } from "../../lib/fetch";
+
+import { createContentDigest } from "../../lib/createContentDigest";
+import { decode } from "../../lib/decode";
+
+import { S3ACL } from "../../types";
+import { SLICE_MACHINE_USER_AGENT } from "../../constants/SLICE_MACHINE_USER_AGENT";
+import { API_ENDPOINTS } from "../../constants/API_ENDPOINTS";
+
+import { BaseManager } from "../BaseManager";
+
+function assertS3ACLInitialized(
+	s3ACL: S3ACL | undefined,
+): asserts s3ACL is NonNullable<typeof s3ACL> {
+	if (s3ACL == undefined) {
+		throw new Error(
+			"An S3 ACL has not been initialized. Run `SliceMachineManager.screenshots.prototype.initS3ACL()` before re-calling this method.",
+		);
+	}
+}
+
+const uploadScreenshotLimit = pLimit(10);
+
+type ScreenshotsManagerUploadScreenshotArgs = {
+	data: Buffer;
+	keyPrefix?: string;
+};
+
+type ScreenshotsManagerUploadScreenshotReturnType = {
+	url: string;
+};
+
+type ScreenshotsManagerDeleteScreenshotFolderArgs = {
+	sliceID: string;
+};
+
+export class ScreenshotsManager extends BaseManager {
+	private _s3ACL: S3ACL | undefined;
+
+	async initS3ACL(): Promise<void> {
+		// TODO: we need to find a way to create a new AWS ACL only when necessary (e.g., when it has expired).
+		// if (this._s3ACL) {
+		// 	return;
+		// }
+
+		const awsACLURL = new URL("create", API_ENDPOINTS.AwsAclProvider);
+		const awsACLRes = await this._fetch({ url: awsACLURL });
+
+		const awsACLText = await awsACLRes.text();
+		let awsACLJSON: unknown;
+		try {
+			awsACLJSON = JSON.parse(awsACLText);
+		} catch (error) {
+			// Response is not JSON
+			throw new Error(
+				`Invalid AWS ACL response from ${awsACLURL}: ${awsACLText}`,
+				{
+					cause: error,
+				},
+			);
+		}
+
+		const { value: awsACL, error } = decode(
+			t.intersection([
+				t.type({
+					values: t.type({
+						url: t.string,
+						fields: t.record(t.string, t.string),
+					}),
+					imgixEndpoint: t.string,
+				}),
+				t.partial({
+					message: t.string,
+					Message: t.string,
+					error: t.string,
+				}),
+			]),
+			awsACLJSON,
+		);
+
+		if (error) {
+			throw new Error(`Invalid AWS ACL response from ${awsACLURL}`, {
+				cause: error,
+			});
+		}
+
+		const errorMessage = awsACL.error || awsACL.message || awsACL.Message;
+		if (errorMessage) {
+			throw new Error(`Failed to create an AWS ACL: ${errorMessage}`, {
+				cause: error,
+			});
+		}
+
+		this._s3ACL = {
+			uploadEndpoint: awsACL.values.url,
+			requiredFormDataFields: awsACL.values.fields,
+			imgixEndpoint: awsACL.imgixEndpoint,
+		};
+	}
+
+	async uploadScreenshot(
+		args: ScreenshotsManagerUploadScreenshotArgs,
+	): Promise<ScreenshotsManagerUploadScreenshotReturnType> {
+		assertS3ACLInitialized(this._s3ACL);
+
+		const formData = new FormData();
+
+		for (const requiredFormDataFieldKey in this._s3ACL.requiredFormDataFields) {
+			formData.append(
+				requiredFormDataFieldKey,
+				this._s3ACL.requiredFormDataFields[requiredFormDataFieldKey],
+			);
+		}
+
+		const contentDigest = createContentDigest(args.data);
+		const fileType = await fileTypeFromBuffer(args.data);
+		const fileName = fileType
+			? `${contentDigest}.${fileType.ext}`
+			: contentDigest;
+		const key = args.keyPrefix ? `${args.keyPrefix}/${fileName}` : fileName;
+
+		formData.set("key", key);
+
+		if (fileType) {
+			formData.set("Content-Type", fileType.mime);
+		}
+
+		formData.set("file", new Blob([args.data], { type: fileType?.mime }));
+
+		const s3ACLEndpoint = this._s3ACL.uploadEndpoint;
+		const res = await uploadScreenshotLimit(() =>
+			fetch(s3ACLEndpoint, {
+				method: "POST",
+				body: formData,
+			}),
+		);
+
+		if (res.ok) {
+			const url = new URL(key, this._s3ACL.imgixEndpoint);
+			url.searchParams.set("auto", "compress,format");
+
+			return {
+				url: url.toString(),
+			};
+		} else {
+			const text = await res.text();
+			throw new Error(
+				`Unable to upload screenshot with status code: ${res.status}`,
+				{
+					cause: text,
+				},
+			);
+		}
+	}
+
+	async deleteScreenshotFolder(
+		args: ScreenshotsManagerDeleteScreenshotFolderArgs,
+	): Promise<void> {
+		const res = await this._fetch({
+			// We're sending `args.sliceID` as `sliceName` because it's inconsistently
+			// named in the ACL Provider API.
+			body: { sliceName: args.sliceID },
+			method: "POST",
+			url: new URL("delete-folder", API_ENDPOINTS.AwsAclProvider),
+		});
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(
+				`Unable to delete screenshot folder with status code: ${res.status}`,
+				{
+					cause: text,
+				},
+			);
+		}
+	}
+
+	private async _fetch(args: {
+		url: URL;
+		method?: "GET" | "POST";
+		body?: unknown;
+	}): Promise<Response> {
+		const authenticationToken = await this.user.getAuthenticationToken();
+		const repositoryName = await this.project.getRepositoryName();
+
+		return await fetch(args.url, {
+			body: args.body ? JSON.stringify(args.body) : undefined,
+			headers: {
+				Authorization: `Bearer ${authenticationToken}`,
+				Repository: repositoryName,
+				"User-Agent": SLICE_MACHINE_USER_AGENT,
+				...(args.body ? { "Content-Type": "application/json" } : {}),
+			},
+			method: args.method,
+		});
+	}
+}

package/src/managers/simulator/SimulatorManager.ts

@@ -0,0 +1,161 @@
+import * as t from "io-ts";
+import { HookError } from "@slicemachine/plugin-kit";
+import fetch from "../../lib/fetch";
+
+import { DecodeError } from "../../lib/DecodeError";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { castArray } from "../../lib/castArray";
+import { decode } from "../../lib/decode";
+import { decodeHookResult } from "../../lib/decodeHookResult";
+import { functionCodec } from "../../lib/functionCodec";
+import { markdownToHTML } from "../../lib/markdownToHTML";
+
+import { UnexpectedDataError } from "../../errors";
+
+import { BaseManager } from "../BaseManager";
+
+const sliceSimulatorSetupStepCodec = t.intersection([
+	t.type({
+		title: t.string,
+		body: t.string,
+	}),
+	t.partial({
+		description: t.string,
+		validate: functionCodec,
+	}),
+]);
+
+const SliceSimulatorSetupStepValidationMessageCodec = t.type({
+	title: t.string,
+	message: t.string,
+});
+type SliceSimulatorSetupStepValidationMessageCodec = t.TypeOf<
+	typeof SliceSimulatorSetupStepValidationMessageCodec
+>;
+
+export type SimulatorManagerReadSliceSimulatorSetupStep = {
+	title: string;
+	description?: string;
+	body: string;
+	/**
+	 * Determines if the step is completed.
+	 *
+	 * This proeprty is `undefined` if the project's adapter does not provide a
+	 * validation function for the step; we cannot know if the step is complete
+	 * without a validator.
+	 */
+	isComplete: boolean | undefined;
+	validationMessages: SliceSimulatorSetupStepValidationMessageCodec[];
+};
+
+export type SimulatorManagerReadSliceSimulatorSetupStepsReturnType = {
+	steps: SimulatorManagerReadSliceSimulatorSetupStep[];
+	errors: (DecodeError | HookError)[];
+};
+
+export class SimulatorManager extends BaseManager {
+	async getLocalSliceSimulatorURL(): Promise<string | undefined> {
+		const sliceMachineConfig = await this.project.getSliceMachineConfig();
+
+		return sliceMachineConfig.localSliceSimulatorURL;
+	}
+
+	/**
+	 * @throws {@link UnexpectedDataError} Thrown if the project is not configured
+	 *   with a Slice Simulator URL.
+	 */
+	async checkIsLocalSliceSimulatorURLAccessible(): Promise<boolean> {
+		const localSliceSimulatorURL = await this.getLocalSliceSimulatorURL();
+
+		if (!localSliceSimulatorURL) {
+			throw new UnexpectedDataError(
+				"The project has not been configured with a Slice Simulator URL. Add a `localSliceSimulatorURL` property to your project's configuration to fix this error.",
+			);
+		}
+
+		const res = await fetch(localSliceSimulatorURL);
+
+		return res.ok;
+	}
+
+	async readSliceSimulatorSetupSteps(): Promise<SimulatorManagerReadSliceSimulatorSetupStepsReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"slice-simulator:setup:read",
+			undefined,
+		);
+		const { data, errors } = decodeHookResult(
+			t.array(sliceSimulatorSetupStepCodec),
+			hookResult,
+		);
+
+		const steps = await Promise.all(
+			data[0].map(async (step) => {
+				const bodyHTML = await markdownToHTML(step.body);
+
+				const res: SimulatorManagerReadSliceSimulatorSetupStep = {
+					title: step.title,
+					description: step.description,
+					body: bodyHTML,
+					isComplete: undefined,
+					validationMessages: [],
+				};
+
+				if (step.validate) {
+					const validationResult = await step.validate();
+					const { value: validationMessages, error } = decode(
+						t.array(SliceSimulatorSetupStepValidationMessageCodec),
+						validationResult == null ? [] : castArray(validationResult),
+					);
+
+					if (error) {
+						// TODO: We may want to do
+						// something with the error,
+						// like log to the console.
+						// This branch should only be
+						// reached if the adapter
+						// returns invalid data.
+
+						return res;
+					}
+
+					const isComplete = validationMessages.length < 1;
+
+					const processedValidationMessages = await Promise.all(
+						validationMessages.map(async (validationMessage) => {
+							const messageHTML = await markdownToHTML(
+								validationMessage.message,
+							);
+
+							return {
+								...validationMessage,
+								message: messageHTML,
+							};
+						}),
+					);
+
+					res.isComplete = isComplete;
+					res.validationMessages = processedValidationMessages;
+				}
+
+				return res;
+			}),
+		);
+
+		return {
+			steps,
+			errors,
+		};
+	}
+
+	supportsSliceSimulator(): boolean {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hooks = this.sliceMachinePluginRunner.hooksForType(
+			"slice-simulator:setup:read",
+		);
+
+		return hooks.length > 0;
+	}
+}

package/src/managers/sliceTemplateLibrary/SliceTemplateLibraryManager.ts

@@ -0,0 +1,201 @@
+import * as t from "io-ts";
+import { HookError } from "@slicemachine/plugin-kit";
+import { BaseManager } from "../BaseManager";
+import { DecodeError } from "../../lib/DecodeError";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { decodeHookResult } from "../../lib/decodeHookResult";
+import { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+import { SharedSliceContent } from "@prismicio/types-internal/lib/content";
+
+type SliceTemplateLibraryManagerReadLibraryReturnType = {
+	templates: {
+		model: SharedSlice;
+		screenshots: Record<string, Buffer>;
+	}[];
+	errors: (DecodeError | HookError)[];
+};
+
+type SliceTemplateLibraryManagerCreateSlicesReturnType = {
+	data?: {
+		sliceIDs: string[];
+	};
+	errors: (DecodeError | HookError)[];
+};
+
+type SliceTemplateLibraryReadLibraryData = {
+	templateIDs?: string[];
+};
+
+type SliceTemplateLibraryCreateSlicesData = SliceTemplateLibraryReadLibraryData;
+
+const readHookCodec = t.type({
+	templates: t.array(
+		t.type({
+			model: SharedSlice,
+			componentContentsTemplate: t.string,
+			mocks: t.array(SharedSliceContent),
+			screenshots: t.record(t.string, t.any),
+		}),
+	),
+});
+
+const replacePascalNameToReplace = (template: string, name: string) =>
+	template.replaceAll("PascalNameToReplace", name);
+
+export class SliceTemplateLibraryManager extends BaseManager {
+	async readLibrary(
+		args: SliceTemplateLibraryReadLibraryData,
+	): Promise<SliceTemplateLibraryManagerReadLibraryReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hookResult = await this.sliceMachinePluginRunner.callHook(
+			"slice-template-library:read",
+			args,
+		);
+
+		const { data, errors } = decodeHookResult(readHookCodec, hookResult);
+
+		return {
+			templates: data.flat().flatMap((item) =>
+				item.templates.map((t) => ({
+					model: t.model,
+					screenshots: t.screenshots,
+				})),
+			),
+			errors,
+		};
+	}
+	async createSlices(
+		args: SliceTemplateLibraryCreateSlicesData,
+	): Promise<SliceTemplateLibraryManagerCreateSlicesReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		// Reading all available slice templates
+		const hookReadResult = await this.sliceMachinePluginRunner.callHook(
+			"slice-template-library:read",
+			args,
+		);
+		const { data: readData, errors: readErrors } = decodeHookResult(
+			readHookCodec,
+			hookReadResult,
+		);
+		const templates = readData.flat().flatMap((item) => item.templates);
+		if (readErrors.length > 0) {
+			return {
+				errors: readErrors,
+			};
+		}
+
+		// Extract all existing slice IDs into an array
+		const { models: allSlices, errors: readAllSlicesErrors } =
+			await this.slices.readAllSlices();
+		if (readAllSlicesErrors.length > 0) {
+			return {
+				errors: readAllSlicesErrors,
+			};
+		}
+		const existingIds: string[] = allSlices.map((slice) => slice.model.id);
+
+		// Create a function to get the next available ID based on the baseId
+		const getNextAvailableSlice = (baseId: string) => {
+			let nextId = baseId;
+			let counter = 1;
+			while (existingIds.includes(nextId)) {
+				counter++;
+				nextId = `${baseId}_${counter}`;
+			}
+			existingIds.push(nextId);
+
+			return { id: nextId, counter };
+		};
+
+		// Extract the slices to create from the template ids given in args
+		const slicesToCreate = templates.map((template) => {
+			const { id, counter } = getNextAvailableSlice(template.model.id);
+
+			return {
+				...template,
+				model: {
+					...template.model,
+					id,
+					name:
+						counter > 1 ? template.model.name + counter : template.model.name,
+				},
+			};
+		});
+
+		// Get target library
+		// Note: We only support adding template to the first library at the moment
+		const { libraries, errors: readAllSliceLibrariesErrors } =
+			await this.slices.readAllSliceLibraries();
+		if (readAllSliceLibrariesErrors.length > 0) {
+			return {
+				errors: readAllSliceLibrariesErrors,
+			};
+		}
+		const targetLibrary = libraries[0];
+
+		// Initiate the slice creation process for all slices
+		const creationPromises = slicesToCreate.map((slice) => {
+			return this.slices.createSlice({
+				libraryID: targetLibrary.libraryID,
+				model: slice.model,
+				componentContents: replacePascalNameToReplace(
+					slice.componentContentsTemplate,
+					slice.model.name,
+				),
+			});
+		});
+
+		// Wait for all slices to be created
+		const creationResults = await Promise.all(creationPromises);
+		// Check for any errors in the creation results
+		const creationErrors = creationResults.flatMap((result) => result.errors);
+		if (creationErrors.length > 0) {
+			return {
+				errors: creationErrors,
+			};
+		}
+
+		const mocksPromises = slicesToCreate.map((slice) => {
+			return this.slices.updateSliceMocks({
+				libraryID: targetLibrary.libraryID,
+				sliceID: slice.model.id,
+				mocks: slice.mocks,
+			});
+		});
+
+		const mocksResults = await Promise.all(mocksPromises);
+
+		const sliceScreenshotsPromises = slicesToCreate.map((slice) => {
+			const screenshotPromises = Object.entries(slice.screenshots).map(
+				([variationID, data]) => {
+					return this.slices.updateSliceScreenshot({
+						libraryID: targetLibrary.libraryID,
+						sliceID: slice.model.id,
+						variationID,
+						data,
+					});
+				},
+			);
+
+			return Promise.all(screenshotPromises);
+		});
+
+		const sliceScreenshotsResults = await Promise.all(sliceScreenshotsPromises);
+		const mocksErrors = mocksResults.flatMap((result) => result.errors);
+		const screenshotErrors = sliceScreenshotsResults.flatMap((result) =>
+			result.flat().flatMap((r) => r.errors),
+		);
+
+		// Extract the slice IDs from the creation results (assuming each result has an ID)
+		const sliceIDs = slicesToCreate.map((slice) => slice.model.id);
+
+		return {
+			errors: [...mocksErrors, ...screenshotErrors],
+			data: {
+				sliceIDs,
+			},
+		};
+	}
+}