@slicemachine/manager 0.1.1-dev-plugins-testing.0 → 0.1.1-dev-plugins-validation.0

package/src/managers/prismicRepository/PrismicRepositoryManager.ts

@@ -1,5 +1,6 @@
 import * as t from "io-ts";
 import fetch, { Response } from "node-fetch";
+import { fold } from "fp-ts/Either";
 
 import { decode } from "../../lib/decode";
 import { serializeCookies } from "../../lib/serializeCookies";
@@ -10,11 +11,22 @@ import { API_ENDPOINTS } from "../../constants/API_ENDPOINTS";
 import { BaseManager } from "../BaseManager";
 
 import {
+	AllChangeTypes,
+	BulkBody,
+	ChangeTypes,
+	ClientError,
+	Limit,
+	LimitType,
 	PrismicRepository,
 	PrismicRepositoryRole,
 	PrismicRepositoryUserAgent,
 	PrismicRepositoryUserAgents,
+	RawLimit,
+	TransactionalMergeArgs,
+	TransactionalMergeReturnType,
 } from "./types";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { UnauthenticatedError } from "../../errors";
 
 const DEFAULT_REPOSITORY_SETTINGS = {
 	plan: "personal",
@@ -237,6 +249,173 @@ export class PrismicRepositoryManager extends BaseManager {
 		}
 	}
 
+	async pushChanges(
+		args: TransactionalMergeArgs,
+	): Promise<TransactionalMergeReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		if (!(await this.user.checkIsLoggedIn())) {
+			throw new UnauthenticatedError();
+		}
+
+		try {
+			const allChanges: AllChangeTypes[] = await Promise.all(
+				args.changes.map(async (change) => {
+					if (change.type === "Slice") {
+						switch (change.status) {
+							case "NEW": {
+								const { model } = await this.slices.readSlice({
+									libraryID: change.libraryID,
+									sliceID: change.id,
+								});
+
+								if (!model) {
+									throw Error(`Could not find model ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.SLICE_INSERT,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "MODIFIED": {
+								const { model } = await this.slices.readSlice({
+									libraryID: change.libraryID,
+									sliceID: change.id,
+								});
+
+								if (!model) {
+									throw Error(`Could not find model  ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.SLICE_UPDATE,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "DELETED":
+								return {
+									id: change.id,
+									payload: { id: change.id },
+									type: ChangeTypes.SLICE_DELETE,
+								};
+						}
+					} else {
+						switch (change.status) {
+							case "NEW": {
+								const { model } = await this.customTypes.readCustomType({
+									id: change.id,
+								});
+								if (!model) {
+									throw Error(`Could not find model ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.CUSTOM_TYPE_INSERT,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "MODIFIED": {
+								const { model } = await this.customTypes.readCustomType({
+									id: change.id,
+								});
+								if (!model) {
+									throw Error(`Could not find model ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.CUSTOM_TYPE_UPDATE,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "DELETED":
+								return {
+									id: change.id,
+									payload: { id: change.id },
+									type: ChangeTypes.CUSTOM_TYPE_DELETE,
+								};
+						}
+					}
+				}),
+			);
+
+			// Compute the POST body
+			const requestBody: BulkBody = {
+				confirmDeleteDocuments: args.confirmDeleteDocuments,
+				changes: allChanges,
+			};
+
+			const authenticationToken = await this.user.getAuthenticationToken();
+			const sliceMachineConfig = await this.project.getSliceMachineConfig();
+
+			// TODO: API route in consts ends with /customtypes
+			// TODO: move to customtypes client
+			return fetch("https://customtypes.prismic.io/bulk", {
+				body: JSON.stringify(requestBody),
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${authenticationToken}`,
+					"User-Agent": "slice-machine",
+					repository: sliceMachineConfig.repositoryName,
+					"Content-Type": "application/json",
+				},
+			})
+				.then(async (response) => {
+					if (response.status === 204) {
+						return null;
+					}
+
+					return this._decodeLimitOrThrow(
+						await response.json(),
+						response.status,
+						LimitType.SOFT,
+					);
+				})
+				.catch((err: ClientError) => {
+					// Try to decode a limit from the error or throw the original error
+					try {
+						const data: unknown = JSON.parse(err.message);
+
+						return this._decodeLimitOrThrow(data, err.status, LimitType.HARD);
+					} catch {
+						throw err;
+					}
+				});
+		} catch (err) {
+			console.error("An error happened while pushing your changes");
+			console.error(err);
+
+			throw err;
+		}
+	}
+
+	private _decodeLimitOrThrow(
+		potentialLimit: unknown,
+		statusCode: number,
+		limitType: LimitType,
+	): Limit | null {
+		return fold<t.Errors, RawLimit, Limit | null>(
+			() => {
+				const error: ClientError = {
+					status: statusCode,
+					message: `Unable to parse raw limit from ${JSON.stringify(
+						potentialLimit,
+					)}`,
+				};
+				throw error;
+			},
+			(rawLimit: RawLimit) => {
+				const limit = { ...rawLimit, type: limitType };
+
+				return limit;
+			},
+		)(RawLimit.decode(potentialLimit));
+	}
+
 	private async _fetch(args: {
 		url: URL;
 		method?: "GET" | "POST";

package/src/managers/prismicRepository/types.ts

@@ -1,3 +1,4 @@
+import { CustomTypes } from "@prismicio/types-internal";
 import * as t from "io-ts";
 
 export const PrismicRepositoryUserAgent = {
@@ -5,7 +6,7 @@ export const PrismicRepositoryUserAgent = {
 	LegacyZero: "prismic-cli/0",
 } as const;
 export type PrismicRepositoryUserAgents =
-	typeof PrismicRepositoryUserAgent[keyof typeof PrismicRepositoryUserAgent];
+	(typeof PrismicRepositoryUserAgent)[keyof typeof PrismicRepositoryUserAgent];
 
 export const PrismicRepositoryRole = {
 	SuperUser: "SuperUser",
@@ -17,7 +18,7 @@ export const PrismicRepositoryRole = {
 	Readonly: "Readonly",
 } as const;
 export type PrismicRepositoryRoles =
-	typeof PrismicRepositoryRole[keyof typeof PrismicRepositoryRole];
+	(typeof PrismicRepositoryRole)[keyof typeof PrismicRepositoryRole];
 
 export const PrismicRepository = t.type({
 	domain: t.string,
@@ -28,3 +29,102 @@ export const PrismicRepository = t.type({
 	]),
 });
 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: CustomTypes.Widgets.Slices.SharedSlice;
+}
+export interface SliceUpdateChange extends Change {
+	type: ChangeTypes.SLICE_UPDATE;
+	payload: CustomTypes.Widgets.Slices.SharedSlice;
+}
+export interface SliceDeleteChange extends DeleteChange {
+	type: ChangeTypes.SLICE_DELETE;
+}
+export interface CustomTypeInsertChange extends Change {
+	type: ChangeTypes.CUSTOM_TYPE_INSERT;
+	payload: CustomTypes.CustomType;
+}
+export interface CustomTypeUpdateChange extends Change {
+	type: ChangeTypes.CUSTOM_TYPE_UPDATE;
+	payload: CustomTypes.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;

package/src/managers/project/ProjectManager.ts

@@ -2,18 +2,24 @@ 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 { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
 import { decodeSliceMachineConfig } from "../../lib/decodeSliceMachineConfig";
+import { format } from "../../lib/format";
+import { installDependencies } from "../../lib/installDependencies";
 import { locateFileUpward } from "../../lib/locateFileUpward";
 
-import { SliceMachineConfig } from "../../types";
+import { PackageManager, SliceMachineConfig } from "../../types";
+
+import { SliceMachineError, InternalError } 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";
-import { format } from "../../lib/format";
 
 type ProjectManagerGetSliceMachineConfigPathArgs = {
 	ignoreCache?: boolean;
@@ -32,6 +38,25 @@ type ProjectManagerWriteSliceMachineConfigArgs = {
 	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;
+};
+
 export class ProjectManager extends BaseManager {
 	private _cachedRoot: string | undefined;
 	private _cachedSliceMachineConfigPath: string | undefined;
@@ -162,4 +187,95 @@ export class ProjectManager extends BaseManager {
 
 		return path.dirname(sliceMachinePackageJSONPath);
 	}
+
+	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;
+		}
+	}
 }

package/src/managers/slices/SlicesManager.ts

@@ -62,7 +62,7 @@ type SliceMachineManagerReadAllSlicesReturnType = {
 };
 
 type SliceMachineManagerReadSliceReturnType = {
-	model: CustomTypes.Widgets.Slices.SharedSlice;
+	model: CustomTypes.Widgets.Slices.SharedSlice | undefined;
 	errors: (DecodeError | HookError)[];
 };
 

package/src/managers/telemetry/TelemetryManager.ts

@@ -14,6 +14,11 @@ import {
 	SegmentEvents,
 } from "./types";
 
+type TelemetryManagerInitTelemetryArgs = {
+	appName: string;
+	appVersion: string;
+};
+
 type TelemetryManagerTrackArgs = SegmentEvents;
 
 type TelemetryManagerIdentifyArgs = {
@@ -21,6 +26,21 @@ type TelemetryManagerIdentifyArgs = {
 	intercomHash: string;
 };
 
+type TelemetryManagerGroupArgs = {
+	repositoryName: string;
+	manualLibsCount: number;
+	downloadedLibsCount: number;
+	npmLibsCount: number;
+	downloadedLibs: string[];
+};
+
+type TelemetryManagerContext = {
+	app: {
+		name: string;
+		version: string;
+	};
+};
+
 function assertTelemetryInitialized(
 	segmentClient: SegmentClient | undefined,
 ): asserts segmentClient is NonNullable<typeof segmentClient> {
@@ -32,30 +52,22 @@ function assertTelemetryInitialized(
 }
 
 export class TelemetryManager extends BaseManager {
-	private _enabled = false;
 	private _segmentClient: SegmentClient | undefined = undefined;
 	private _anonymousID: string | undefined = undefined;
 	private _userID: string | undefined = undefined;
+	private _context: TelemetryManagerContext | undefined = undefined;
 
-	async initTelemetry(): Promise<void> {
+	async initTelemetry(args: TelemetryManagerInitTelemetryArgs): Promise<void> {
 		if (this._segmentClient) {
 			// Prevent subsequent initializations.
 			return;
 		}
 
-		let root: string;
-		try {
-			root = await this.project.getRoot();
-		} catch {
-			root = await this.project.suggestRoot();
-		}
-
-		this._enabled = readPrismicrc(root).telemetry !== false;
 		this._segmentClient = new SegmentClient(API_TOKENS.SegmentKey, {
 			// Since it's a local app, we do not benefit from event batching the way a server would normally do, all tracking event will be awaited.
 			flushAt: 1,
 			// TODO: Verify that this actually does not send data to Segment when false.
-			enable: this._enabled,
+			enable: await this.checkIsTelemetryEnabled(),
 			errorHandler: () => {
 				// noop - We don't care if the tracking event
 				// failed. Some users or networks intentionally
@@ -64,6 +76,7 @@ export class TelemetryManager extends BaseManager {
 			},
 		});
 		this._anonymousID = randomUUID();
+		this._context = { app: { name: args.appName, version: args.appVersion } };
 	}
 
 	// TODO: Should `userId` be automatically populated by the logged in
@@ -76,7 +89,7 @@ export class TelemetryManager extends BaseManager {
 			userId?: string;
 			anonymousId?: string;
 			properties?: Record<string, unknown>;
-			context?: {
+			context?: Partial<TelemetryManagerContext> & {
 				groupId?: {
 					Repository?: string;
 				};
@@ -84,9 +97,11 @@ export class TelemetryManager extends BaseManager {
 		} = {
 			event: HumanSegmentEventType[event],
 			properties: {
+				nodeVersion: process.versions.node,
 				repo: repository,
 				...properties,
 			},
+			context: { ...this._context },
 		};
 
 		if (this._userID) {
@@ -105,14 +120,20 @@ export class TelemetryManager extends BaseManager {
 			assertTelemetryInitialized(this._segmentClient);
 
 			// TODO: Make sure client fails gracefully when no internet connection
-			this._segmentClient.track(payload, (maybeError?: Error) => {
-				if (maybeError) {
-					// TODO: Not sure how we want to deal with that
-					console.warn(`An error occurred during Segment tracking`, maybeError);
-				}
-
-				resolve();
-			});
+			this._segmentClient.track(
+				payload as Parameters<typeof this._segmentClient.track>[0],
+				(maybeError?: Error) => {
+					if (maybeError) {
+						// TODO: Not sure how we want to deal with that
+						console.warn(
+							`An error occurred during Segment tracking`,
+							maybeError,
+						);
+					}
+
+					resolve();
+				},
+			);
 		});
 	}
 
@@ -120,20 +141,22 @@ export class TelemetryManager extends BaseManager {
 	// by the logged in user? We already have their info via
 	// UserRepository.
 	identify(args: TelemetryManagerIdentifyArgs): Promise<void> {
+		const payload = {
+			userId: args.userID,
+			anonymousId: this._anonymousID,
+			integrations: {
+				Intercom: {
+					user_hash: args.intercomHash,
+				},
+			},
+			context: { ...this._context },
+		};
+
+		this._userID = args.userID;
+
 		return new Promise((resolve) => {
 			assertTelemetryInitialized(this._segmentClient);
 
-			const payload = {
-				userId: args.userID,
-				anonymousId: this._anonymousID,
-				integrations: {
-					Intercom: {
-						user_hash: args.intercomHash,
-					},
-				},
-			};
-			this._userID = args.userID;
-
 			// TODO: Make sure client fails gracefully when no internet connection
 			this._segmentClient.identify(payload, (maybeError?: Error) => {
 				if (maybeError) {
@@ -145,4 +168,53 @@ export class TelemetryManager extends BaseManager {
 			});
 		});
 	}
+
+	group(args: TelemetryManagerGroupArgs): Promise<void> {
+		const { repositoryName, ...traits } = args;
+
+		const payload: {
+			groupId: string;
+			userId?: string;
+			anonymousId?: string;
+			traits?: Record<string, unknown>;
+			context?: Partial<TelemetryManagerContext>;
+		} = {
+			groupId: repositoryName,
+			traits,
+			context: { ...this._context },
+		};
+
+		if (this._userID) {
+			payload.userId = this._userID;
+		} else {
+			payload.anonymousId = this._anonymousID;
+		}
+
+		return new Promise((resolve) => {
+			assertTelemetryInitialized(this._segmentClient);
+
+			this._segmentClient.group(
+				payload as Parameters<typeof this._segmentClient.group>[0],
+				(maybeError?: Error) => {
+					if (maybeError) {
+						// TODO: Not sure how we want to deal with that
+						console.warn(`An error occurred during Segment group`, maybeError);
+					}
+
+					resolve();
+				},
+			);
+		});
+	}
+
+	async checkIsTelemetryEnabled(): Promise<boolean> {
+		let root: string;
+		try {
+			root = await this.project.getRoot();
+		} catch {
+			root = await this.project.suggestRoot();
+		}
+
+		return readPrismicrc(root).telemetry !== false;
+	}
 }