@slicemachine/manager 0.1.1-dev-plugins.11 → 0.1.1-dev-plugins.13

package/src/managers/createSliceMachineManager.ts

@@ -2,10 +2,10 @@ import { SliceMachineManager } from "./SliceMachineManager";
 
 type CreateSliceMachineManagerArgs = ConstructorParameters<
 	typeof SliceMachineManager
->[0];
+>;
 
 export const createSliceMachineManager = (
-	args?: CreateSliceMachineManagerArgs,
+	...args: CreateSliceMachineManagerArgs
 ): SliceMachineManager => {
-	return new SliceMachineManager(args);
+	return new SliceMachineManager(...args);
 };

package/src/managers/slices/SlicesManager.ts

@@ -104,7 +104,7 @@ type SliceMachineManagerReadSliceMocksArgs = {
 
 type SliceMachineManagerReadSliceMocksReturnType = {
 	mocks?: SharedSliceContent[];
-	errors: HookError[];
+	errors: (DecodeError | HookError)[];
 };
 
 type SliceMachineManagerReadSliceMocksConfigArgs = {
@@ -467,19 +467,36 @@ export class SlicesManager extends BaseManager {
 				assetID: `mocks.json`,
 			},
 		);
-		const data = hookResult.data[0]?.data;
-
-		// TODO: Validate the returned mocks.
+		const { data, errors } = decodeHookResult(
+			t.type({
+				data: t.array(SharedSliceContent),
+			}),
+			{
+				...hookResult,
+				// Convert the asset data from a Buffer to JSON
+				// to prepare it for validation.
+				data: hookResult.data.map((result) => {
+					try {
+						return {
+							...result,
+							data: JSON.parse(result.data.toString()),
+						};
+					} catch {
+						return result;
+					}
+				}),
+			},
+		);
 
 		if (data) {
 			return {
-				mocks: JSON.parse(data.toString()),
-				errors: hookResult.errors,
+				mocks: data[0]?.data,
+				errors,
 			};
 		} else {
 			return {
 				mocks: [],
-				errors: hookResult.errors,
+				errors,
 			};
 		}
 	}

package/src/managers/telemetry/TelemetryManager.ts

@@ -56,6 +56,12 @@ export class TelemetryManager extends BaseManager {
 			flushAt: 1,
 			// TODO: Verify that this actually does not send data to Segment when false.
 			enable: this._enabled,
+			errorHandler: () => {
+				// noop - We don't care if the tracking event
+				// failed. Some users or networks intentionally
+				// block Segment, so we can't block the app if
+				// a tracking event is unsuccessful.
+			},
 		});
 		this._anonymousID = randomUUID();
 	}

package/src/managers/user/UserManager.ts

@@ -1,6 +1,18 @@
+import { SliceMachineError } from "../../errors";
 import { BaseManager } from "../BaseManager";
+import { SliceMachineManager } from "../SliceMachineManager";
 
 export class UserManager extends BaseManager {
+	constructor(sliceMachineManager: SliceMachineManager) {
+		super(sliceMachineManager);
+
+		if (!sliceMachineManager.getPrismicAuthManager()) {
+			throw new SliceMachineError(
+				"SliceMachineManager._prismicAuthManager must be set with a PrismicAuthManager instance before instantiating UserManager.",
+			);
+		}
+	}
+
 	login = this.prismicAuthManager.login.bind(this.prismicAuthManager);
 	getLoginSessionInfo = this.prismicAuthManager.getLoginSessionInfo.bind(
 		this.prismicAuthManager,

package/src/managers/versions/VersionsManager.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import semver from "semver";
 
+import { decodePackageJSON } from "../../lib/decodePackageJSON";
 import {
 	fetchGitHubReleaseBodyForRelease,
 	GitHubReleaseMetadata,
@@ -21,12 +22,14 @@ import { Version } from "./types";
 const detectVersionBumpKind = (
 	to: string,
 	from?: string,
-): typeof VERSION_KIND[keyof typeof VERSION_KIND] => {
+): typeof VERSION_KIND[keyof typeof VERSION_KIND] | undefined => {
 	if (!from) {
 		return VERSION_KIND.FIRST;
 	}
 
-	if (semver.satisfies(to, `~${from}`)) {
+	if (semver.eq(to, from)) {
+		return undefined;
+	} else if (semver.satisfies(to, `~${from}`)) {
 		return VERSION_KIND.PATCH;
 	} else if (semver.satisfies(to, `^${from}`)) {
 		return VERSION_KIND.MINOR;
@@ -56,11 +59,24 @@ export class VersionsManager extends BaseManager {
 			"utf8",
 		);
 
-		// TODO: Validate the contents? This code currently assumes a
-		// well-formed document.
-		const json = JSON.parse(sliceMachinePackageJSONContents);
+		let sliceMachinePackageJSON: unknown;
+		try {
+			sliceMachinePackageJSON = JSON.parse(sliceMachinePackageJSONContents);
+		} catch {
+			// noop
+		}
 
-		return json.version;
+		const { value, error } = decodePackageJSON(sliceMachinePackageJSON);
+
+		if (error) {
+			throw new Error(
+				`Invalid ${SLICE_MACHINE_NPM_PACKAGE_NAME} \`package.json\` file. ${error.errors.join(
+					", ",
+				)}`,
+			);
+		}
+
+		return value.version;
 	}
 
 	async getAllStableSliceMachineVersions(): Promise<string[]> {

package/src/managers/versions/types.ts

@@ -2,5 +2,5 @@ import { VERSION_KIND } from "../../constants/VERSION_KIND";
 
 export type Version = {
 	version: string;
-	kind: typeof VERSION_KIND[keyof typeof VERSION_KIND];
+	kind: typeof VERSION_KIND[keyof typeof VERSION_KIND] | undefined;
 };

package/src/types.ts

@@ -13,7 +13,7 @@ export type PackageChangelog = {
 export type PackageVersion = {
 	versionNumber: string;
 	releaseNote: string | null;
-	kind: typeof VERSION_KIND[keyof typeof VERSION_KIND] | null;
+	kind: typeof VERSION_KIND[keyof typeof VERSION_KIND] | undefined;
 };
 
 /**