@slicemachine/manager 0.1.1-dev-plugins-m1-validation.0 → 0.1.1-dev-plugins-m2-validation.1

package/src/managers/SliceMachineManager.ts

@@ -1,5 +1,9 @@
 import { CustomTypes } from "@prismicio/types-internal";
 import { SharedSliceContent } from "@prismicio/types-internal/lib/content";
+import {
+	ForbiddenError,
+	UnauthorizedError,
+} from "@prismicio/custom-types-client";
 import {
 	SliceMachinePlugin,
 	SliceMachinePluginRunner,
@@ -44,6 +48,7 @@ type SliceMachineManagerGetStateReturnType = {
 		repo: string;
 		changelog?: PackageChangelog;
 		packageManager: PackageManager;
+		supportsSliceSimulator: boolean;
 	};
 	libraries: {
 		name: string;
@@ -163,7 +168,7 @@ export class SliceMachineManager {
 	async getState(): Promise<SliceMachineManagerGetStateReturnType> {
 		const [
 			{ sliceMachineConfig, libraries },
-			{ profile, remoteCustomTypes, remoteSlices },
+			{ profile, remoteCustomTypes, remoteSlices, authError },
 			customTypes,
 			packageManager,
 		] = await Promise.all([
@@ -173,42 +178,63 @@ export class SliceMachineManager {
 				return { sliceMachineConfig, libraries };
 			}),
 			this._getProfile().then(async (profile) => {
+				let authError;
 				if (profile) {
-					const [remoteCustomTypes, remoteSlices] = await Promise.all([
-						this.customTypes.fetchRemoteCustomTypes(),
-						this.slices.fetchRemoteSlices(),
-					]);
-
-					return {
-						profile,
-						remoteCustomTypes,
-						remoteSlices,
-					};
-				} else {
-					return {
-						profile,
-						remoteCustomTypes: [],
-						remoteSlices: [],
-					};
+					try {
+						const [remoteCustomTypes, remoteSlices] = await Promise.all([
+							this.customTypes.fetchRemoteCustomTypes(),
+							this.slices.fetchRemoteSlices(),
+						]);
+
+						return {
+							profile,
+							remoteCustomTypes,
+							remoteSlices,
+							authError,
+						};
+					} catch (error) {
+						// Non-Prismic error
+						if (
+							error instanceof UnauthorizedError ||
+							error instanceof ForbiddenError
+						) {
+							authError = {
+								name: "__stub__",
+								message: "__stub__",
+								reason: "__stub__",
+								status: 401,
+							};
+						} else {
+							throw error;
+						}
+					}
 				}
+
+				return {
+					profile,
+					remoteCustomTypes: [],
+					remoteSlices: [],
+					authError,
+				};
 			}),
 			this._getCustomTypes(),
 			this.project.detectPackageManager(),
 		]);
 
-		// TODO: SM UI detects if a user is logged out by looking at
+		// SM UI detects if a user is logged out by looking at
 		// `clientError`. Here, we simulate what the old core does by
-		// returning an `ErrorWithStatus`-like object if the user is
-		// not logged in.
+		// returning an `ErrorWithStatus`-like object if the user does
+		// not have access to the repository or is not logged in.
 		const clientError: SliceMachineManagerGetStateReturnType["clientError"] =
-			profile
+			authError ||
+			(profile
 				? undefined
 				: {
 						name: "__stub__",
 						message: "__stub__",
 						reason: "__stub__",
 						status: 401, // Needed to trigger the unauthorized flow.
-				  };
+				  });
 
 		return {
 			env: {
@@ -221,6 +247,7 @@ export class SliceMachineManager {
 					localSliceSimulatorURL: sliceMachineConfig.localSliceSimulatorURL,
 				},
 				packageManager,
+				supportsSliceSimulator: this.simulator.supportsSliceSimulator(),
 				repo: sliceMachineConfig.repositoryName,
 				intercomHash: profile?.intercomHash,
 				shortId: profile?.shortId,

package/src/managers/prismicRepository/PrismicRepositoryManager.ts

@@ -371,42 +371,39 @@ export class PrismicRepositoryManager extends BaseManager {
 				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),
+			const response = await this._fetch({
+				url: new URL("/bulk", API_ENDPOINTS.PrismicModels),
 				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;
-					}
+				body: requestBody,
+				repository: sliceMachineConfig.repositoryName,
+			});
 
+			switch (response.status) {
+				case 202:
 					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;
-					}
-				});
+				case 204:
+					return null;
+				case 401:
+					throw new UnauthenticatedError();
+				case 403:
+					return this._decodeLimitOrThrow(
+						await response.json(),
+						response.status,
+						LimitType.HARD,
+					);
+				case 400:
+					const text = await response.text();
+					throw new Error(text);
+				default:
+					throw new Error(`Unexpected status code ${response.status}`);
+			}
 		} catch (err) {
 			console.error("An error happened while pushing your changes");
 			console.error(err);
@@ -443,6 +440,7 @@ export class PrismicRepositoryManager extends BaseManager {
 		method?: "GET" | "POST";
 		body?: unknown;
 		userAgent?: PrismicRepositoryUserAgents;
+		repository?: string;
 	}): Promise<Response> {
 		const cookies = await this.user.getAuthenticationCookies();
 
@@ -452,6 +450,10 @@ export class PrismicRepositoryManager extends BaseManager {
 			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,

package/src/managers/simulator/SimulatorManager.ts

@@ -148,4 +148,14 @@ export class SimulatorManager extends BaseManager {
 			errors,
 		};
 	}
+
+	supportsSliceSimulator(): boolean {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		const hooks = this.sliceMachinePluginRunner.hooksForType(
+			"slice-simulator:setup:read",
+		);
+
+		return hooks.length > 0;
+	}
 }

package/src/managers/telemetry/TelemetryManager.ts

@@ -123,7 +123,7 @@ export class TelemetryManager extends BaseManager {
 			this._segmentClient.track(
 				payload as Parameters<typeof this._segmentClient.track>[0],
 				(maybeError?: Error) => {
-					if (maybeError) {
+					if (maybeError && import.meta.env.DEV) {
 						// TODO: Not sure how we want to deal with that
 						console.warn(
 							`An error occurred during Segment tracking`,
@@ -159,7 +159,7 @@ export class TelemetryManager extends BaseManager {
 
 			// TODO: Make sure client fails gracefully when no internet connection
 			this._segmentClient.identify(payload, (maybeError?: Error) => {
-				if (maybeError) {
+				if (maybeError && import.meta.env.DEV) {
 					// TODO: Not sure how we want to deal with that
 					console.warn(`An error occurred during Segment identify`, maybeError);
 				}
@@ -196,7 +196,7 @@ export class TelemetryManager extends BaseManager {
 			this._segmentClient.group(
 				payload as Parameters<typeof this._segmentClient.group>[0],
 				(maybeError?: Error) => {
-					if (maybeError) {
+					if (maybeError && import.meta.env.DEV) {
 						// TODO: Not sure how we want to deal with that
 						console.warn(`An error occurred during Segment group`, maybeError);
 					}